utdatabase.c

DataDraw is an ultra-fast persistent database for high performance programs written in C. It s so fa

}

/*----------------------------------------------------------------------------------------
  Wrapper around utSymGetNames for the database manager.
----------------------------------------------------------------------------------------*/
static void *getSymNames(
    uint64 objectNumber,
    uint32 *numValues)
{
    utSym Sym = utIndex2Sym(objectNumber);

    *numValues = utSymGetNumName(Sym);
    return utSymGetNames(Sym);
}

/*----------------------------------------------------------------------------------------
  Wrapper around utSymAllocNames for the database manager.
----------------------------------------------------------------------------------------*/
static void *allocSymNames(
    uint64 objectNumber,
    uint32 numValues)
{
    utSym Sym = utIndex2Sym(objectNumber);

    utSymSetNameIndex(Sym, 0);
    utSymSetNumName(Sym, 0);
    if(numValues == 0) {
        return NULL;
    }
    utSymAllocNames(Sym, numValues);
    return utSymGetNames(Sym);
}

/*----------------------------------------------------------------------------------------
  Free memory used by the Sym.Name array.
----------------------------------------------------------------------------------------*/
void utSymFreeNames(
    utSym Sym)
{
    uint32 elementSize = sizeof(char);
    uint32 usedHeaderSize = (sizeof(utSym) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(utSym) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 size = utMax(utSymGetNumName(Sym) + usedHeaderSize, freeHeaderSize);
    char *dataPtr = utSymGetNames(Sym) - usedHeaderSize;

    if(utSymGetNumName(Sym) == 0) {
        return;
    }
    *(utSym *)(void *)(dataPtr) = utSymNull;
    *(uint32 *)(void *)(((utSym *)(void *)dataPtr) + 1) = size;
    utSymSetNumName(Sym, 0);
    utSetFreeSymName(utFreeSymName() + size);
}

/*----------------------------------------------------------------------------------------
  Resize the Sym.Name array.
----------------------------------------------------------------------------------------*/
void utSymResizeNames(
    utSym Sym,
    uint32 numNames)
{
    uint32 freeSpace = utAllocatedSymName() - utUsedSymName();
    uint32 elementSize = sizeof(char);
    uint32 usedHeaderSize = (sizeof(utSym) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(utSym) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 newSize = utMax(numNames + usedHeaderSize, freeHeaderSize);
    uint32 oldSize = utMax(utSymGetNumName(Sym) + usedHeaderSize, freeHeaderSize);
    char *dataPtr;

    if(numNames == 0) {
        if(utSymGetNumName(Sym) != 0) {
            utSymFreeNames(Sym);
        };
        return;
    }
    if(utSymGetNumName(Sym) == 0) {
        utSymAllocNames(Sym, newSize);
        return;
    };
    if(freeSpace < newSize) {
        allocMoreSymNames(newSize);
    }
    dataPtr = utSymGetNames(Sym) - usedHeaderSize;
    memcpy((void *)(utSyms.Name + utUsedSymName()), dataPtr,
        elementSize*utMin(oldSize, newSize));
    if(newSize > oldSize) {
        memset(utSyms.Name + utUsedSymName() + oldSize, 0,
            elementSize*(newSize - oldSize));
    }
    *(utSym *)(void *)dataPtr = utSymNull;
    *(uint32 *)(void *)(((utSym *)(void *)dataPtr) + 1) = oldSize;
    utSetFreeSymName(utFreeSymName() + oldSize);
    utSymSetNameIndex(Sym, utUsedSymName() + usedHeaderSize);
    utSymSetNumName(Sym, numNames);
    utSetUsedSymName(utUsedSymName() + newSize);
}

#if defined(DD_DEBUG)
/*----------------------------------------------------------------------------------------
  Write out all the fields of an object.
----------------------------------------------------------------------------------------*/
void utShowSym(
    utSym Sym)
{
    utDatabaseShowObject("ut", "Sym", utSym2Index(Sym));
}
#endif

/*----------------------------------------------------------------------------------------
  Destroy Dynarray including everything in it. Remove from parents.
----------------------------------------------------------------------------------------*/
void utDynarrayDestroy(
    utDynarray Dynarray)
{
    if(utDynarrayDestructorCallback != NULL) {
        utDynarrayDestructorCallback(Dynarray);
    }
    utDynarrayFree(Dynarray);
}

/*----------------------------------------------------------------------------------------
  Default constructor wrapper for the database manager.
----------------------------------------------------------------------------------------*/
static uint64 allocDynarray(void)
{
    utDynarray Dynarray = utDynarrayAlloc();

    return utDynarray2Index(Dynarray);
}

/*----------------------------------------------------------------------------------------
  Destructor wrapper for the database manager.
----------------------------------------------------------------------------------------*/
static void destroyDynarray(
    uint64 objectIndex)
{
    utDynarrayDestroy(utIndex2Dynarray(objectIndex));
}

/*----------------------------------------------------------------------------------------
  Allocate the field arrays of Dynarray.
----------------------------------------------------------------------------------------*/
static void allocDynarrays(void)
{
    utSetAllocatedDynarray(2);
    utSetUsedDynarray(0);
    utSetFirstFreeDynarray(utDynarrayNull);
    utDynarrays.ValueIndex = utNewA(uint32, (utAllocatedDynarray()));
    utDynarrays.NumValue = utNewA(uint32, (utAllocatedDynarray()));
    utSetUsedDynarrayValue(0);
    utSetAllocatedDynarrayValue(2);
    utSetFreeDynarrayValue(0);
    utDynarrays.Value = utNewA(uint8, utAllocatedDynarrayValue());
    utDynarrays.ValueSize = utNewA(uint16, (utAllocatedDynarray()));
    utDynarrays.UsedValue = utNewA(uint32, (utAllocatedDynarray()));
    utDynarrays.Size = utNewA(uint32, (utAllocatedDynarray()));
}

/*----------------------------------------------------------------------------------------
  Realloc the arrays of properties for class Dynarray.
----------------------------------------------------------------------------------------*/
static void reallocDynarrays(
    uint32 newSize)
{
    utResizeArray(utDynarrays.ValueIndex, (newSize));
    utResizeArray(utDynarrays.NumValue, (newSize));
    utResizeArray(utDynarrays.ValueSize, (newSize));
    utResizeArray(utDynarrays.UsedValue, (newSize));
    utResizeArray(utDynarrays.Size, (newSize));
    utSetAllocatedDynarray(newSize);
}

/*----------------------------------------------------------------------------------------
  Allocate more Dynarrays.
----------------------------------------------------------------------------------------*/
void utDynarrayAllocMore(void)
{
    reallocDynarrays(utAllocatedDynarray() + (utAllocatedDynarray() >> 1));
}

/*----------------------------------------------------------------------------------------
  Compact the Dynarray.Value heap to free memory.
----------------------------------------------------------------------------------------*/
void utCompactDynarrayValues(void)
{
    uint32 elementSize = sizeof(uint8);
    uint32 usedHeaderSize = (sizeof(utDynarray) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(utDynarray) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint8 *toPtr = utDynarrays.Value;
    uint8 *fromPtr = toPtr;
    utDynarray Dynarray;
    uint32 size;

    while(fromPtr < utDynarrays.Value + utUsedDynarrayValue()) {
        Dynarray = *(utDynarray *)(void *)fromPtr;
        if(Dynarray != utDynarrayNull) {
            /* Need to move it to toPtr */
            size = utMax(utDynarrayGetNumValue(Dynarray) + usedHeaderSize, freeHeaderSize);
            memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
            utDynarraySetValueIndex(Dynarray, toPtr - utDynarrays.Value + usedHeaderSize);
            toPtr += size;
        } else {
            /* Just skip it */
            size = *(uint32 *)(void *)(((utDynarray *)(void *)fromPtr) + 1);
        }
        fromPtr += size;
    }
    utSetUsedDynarrayValue(toPtr - utDynarrays.Value);
    utSetFreeDynarrayValue(0);
}

/*----------------------------------------------------------------------------------------
  Allocate more memory for the Dynarray.Value heap.
----------------------------------------------------------------------------------------*/
static void allocMoreDynarrayValues(
    uint32 spaceNeeded)
{
    uint32 freeSpace = utAllocatedDynarrayValue() - utUsedDynarrayValue();

    if((utFreeDynarrayValue() << 2) > utUsedDynarrayValue()) {
        utCompactDynarrayValues();
        freeSpace = utAllocatedDynarrayValue() - utUsedDynarrayValue();
    }
    if(freeSpace < spaceNeeded) {
        utSetAllocatedDynarrayValue(utAllocatedDynarrayValue() + spaceNeeded - freeSpace +
            (utAllocatedDynarrayValue() >> 2));
        utResizeArray(utDynarrays.Value, utAllocatedDynarrayValue());
    }
}

/*----------------------------------------------------------------------------------------
  Allocate memory for a new Dynarray.Value array.
----------------------------------------------------------------------------------------*/
void utDynarrayAllocValues(
    utDynarray Dynarray,
    uint32 numValues)
{
    uint32 freeSpace = utAllocatedDynarrayValue() - utUsedDynarrayValue();
    uint32 elementSize = sizeof(uint8);
    uint32 usedHeaderSize = (sizeof(utDynarray) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(utDynarray) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 spaceNeeded = utMax(numValues + usedHeaderSize, freeHeaderSize);

#if defined(DD_DEBUG)
    utAssert(utDynarrayGetNumValue(Dynarray) == 0);
#endif
    if(numValues == 0) {
        return;
    }
    if(freeSpace < spaceNeeded) {
        allocMoreDynarrayValues(spaceNeeded);
    }
    utDynarraySetValueIndex(Dynarray, utUsedDynarrayValue() + usedHeaderSize);
    utDynarraySetNumValue(Dynarray, numValues);
    *(utDynarray *)(void *)(utDynarrays.Value + utUsedDynarrayValue()) = Dynarray;
    memset(utDynarrayGetValues(Dynarray), 0, numValues*elementSize);
    utSetUsedDynarrayValue(utUsedDynarrayValue() + spaceNeeded);
}

/*----------------------------------------------------------------------------------------
  Wrapper around utDynarrayGetValues for the database manager.
----------------------------------------------------------------------------------------*/
static void *getDynarrayValues(
    uint64 objectNumber,
    uint32 *numValues)
{
    utDynarray Dynarray = utIndex2Dynarray(objectNumber);

    *numValues = utDynarrayGetNumValue(Dynarray);
    return utDynarrayGetValues(Dynarray);
}

/*----------------------------------------------------------------------------------------
  Wrapper around utDynarrayAllocValues for the database manager.
----------------------------------------------------------------------------------------*/
static void *allocDynarrayValues(
    uint64 objectNumber,
    uint32 numValues)
{
    utDynarray Dynarray = utIndex2Dynarray(objectNumber);

    utDynarraySetValueIndex(Dynarray, 0);
    utDynarraySetNumValue(Dynarray, 0);
    if(numValues == 0) {
        return NULL;
    }
    utDynarrayAllocValues(Dynarray, numValues);
    return utDynarrayGetValues(Dynarray);
}

/*----------------------------------------------------------------------------------------
  Free memory used by the Dynarray.Value array.
----------------------------------------------------------------------------------------*/
void utDynarrayFreeValues(
    utDynarray Dynarray)
{
    uint32 elementSize = sizeof(uint8);
    uint32 usedHeaderSize = (sizeof(utDynarray) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(utDynarray) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 size = utMax(utDynarrayGetNumValue(Dynarray) + usedHeaderSize, freeHeaderSize);
    uint8 *dataPtr = utDynarrayGetValues(Dynarray) - usedHeaderSize;

    if(utDynarrayGetNumValue(Dynarray) == 0) {
        return;
    }
    *(utDynarray *)(void *)(dataPtr) = utDynarrayNull;
    *(uint32 *)(void *)(((utDynarray *)(void *)dataPtr) + 1) = size;
    utDynarraySetNumValue(Dynarray, 0);
    utSetFreeDynarrayValue(utFreeDynarrayValue() + size);
}

/*----------------------------------------------------------------------------------------
  Resize the Dynarray.Value array.
----------------------------------------------------------------------------------------*/
void utDynarrayResizeValues(
    utDynarray Dynarray,
    uint32 numValues)
{
    uint32 freeSpace = utAllocatedDynarrayValue() - utUsedDynarrayValue();
    uint32 elementSize = sizeof(uint8);
    uint32 usedHeaderSize = (sizeof(utDynarray) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(utDynarray) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 newSize = utMax(numValues + usedHeaderSize, freeHeaderSize);
    uint32 oldSize = utMax(utDynarrayGetNumValue(Dynarray) + usedHeaderSize, freeHeaderSize);
    uint8 *dataPtr;

    if(numValues == 0) {
        if(utDynarrayGetNumValue(Dynarray) != 0) {
            utDynarrayFreeValues(Dynarray);
        };
        return;
    }
    if(utDynarrayGetNumValue(Dynarray) == 0) {
        utDynarrayAllocValues(Dynarray, newSize);
        return;
    };
    if(freeSpace < newSize) {
        allocMoreDynarrayValues(newSize);
    }
    dataPtr = utDynarrayGetValues(Dynarray) - usedHeaderSize;
    memcpy((void *)(utDynarrays.Value + utUsedDynarrayValue()), dataPtr,
        elementSize*utMin(oldSize, newSize));
    if(newSize > oldSize) {
        memset(utDynarrays.Value + utUsedDynarrayValue() + oldSize, 0,
            elementSize*(newSize - oldSize));
    }
    *(utDynarray *)(void *)dataPtr = utDynarrayNull;
    *(uint32 *)(void *)(((utDynarray *)(void *)dataPtr) + 1) = oldSize;
    utSetFreeDynarrayValue(utFreeDynarrayValue() + oldSize);
    utDynarraySetValueIndex(Dynarray, utUsedDynarrayValue() + usedHeaderSize);
    utDynarraySetNumValue(Dynarray, numValues);
    utSetUsedDynarrayValue(utUsedDynarrayValue() + newSize);
}

#if defined(DD_DEBUG)
/*----------------------------------------------------------------------------------------
  Write out all the fields of an object.
----------------------------------------------------------------------------------------*/
void utShowDynarray(
    utDynarray Dynarray)
{
    utDatabaseShowObject("ut", "Dynarray", utDynarray2Index(Dynarray));
}
#endif

/*----------------------------------------------------------------------------------------
  Destroy SymArray including everything in it. Remove from parents.
----------------------------------------------------------------------------------------*/
void utSymArrayDestroy(
    utSymArray SymArray)
{
    if(utSymArrayDestructorCallback != NULL) {
        utSymArrayDestructorCallback(SymArray);
    }
    utSymArrayFree(SymArray);
}

/*----------------------------------------------------------------------------------------
  Default constructor wrapper for the database manager.
----------------------------------------------------------------------------------------*/
static uint64 allocSymArray(void)
{