utdatabaseup.c

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

    utRecordResize(utModuleID, 4, (utAllocatedSym()), true);
    utResizeArray(utSyms.NameIndex, (newSize));
    utRecordResize(utModuleID, 4, (newSize), false);
    utRecordResize(utModuleID, 5, (utAllocatedSym()), true);
    utResizeArray(utSyms.NumName, (newSize));
    utRecordResize(utModuleID, 5, (newSize), false);
    utRecordResize(utModuleID, 7, (utAllocatedSym()), true);
    utResizeArray(utSyms.HashValue, (newSize));
    utRecordResize(utModuleID, 7, (newSize), false);
    utRecordResize(utModuleID, 8, (utAllocatedSym()), true);
    utResizeArray(utSyms.Next, (newSize));
    utRecordResize(utModuleID, 8, (newSize), false);
    utRecordResize(utModuleID, 9, (utAllocatedSym()), true);
    utResizeArray(utSyms.SymArrayIndex, (newSize));
    utRecordResize(utModuleID, 9, (newSize), false);
    utSetAllocatedSym(newSize);
}

/*----------------------------------------------------------------------------------------
  Allocate more Syms.
----------------------------------------------------------------------------------------*/
void utSymAllocMore(void)
{
    reallocSyms(utAllocatedSym() + (utAllocatedSym() >> 1));
}

/*----------------------------------------------------------------------------------------
  Compact the Sym.Name heap to free memory.
----------------------------------------------------------------------------------------*/
void utCompactSymNames(void)
{
    uint32 elementSize = sizeof(char);
    uint32 usedHeaderSize = (sizeof(utSym) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(utSym) + sizeof(uint32) + elementSize - 1)/elementSize;
    char *toPtr = utSyms.Name;
    char *fromPtr = toPtr;
    utSym Sym;
    uint32 size;

    while(fromPtr < utSyms.Name + utUsedSymName()) {
        Sym = *(utSym *)(void *)fromPtr;
        if(Sym != utSymNull) {
            /* Need to move it to toPtr */
            size = utMax(utSymGetNumName(Sym) + usedHeaderSize, freeHeaderSize);
            memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
            utSymSetNameIndex(Sym, toPtr - utSyms.Name + usedHeaderSize);
            toPtr += size;
        } else {
            /* Just skip it */
            size = *(uint32 *)(void *)(((utSym *)(void *)fromPtr) + 1);
        }
        fromPtr += size;
    }
    utSetUsedSymName(toPtr - utSyms.Name);
    utSetFreeSymName(0);
}

/*----------------------------------------------------------------------------------------
  Allocate more memory for the Sym.Name heap.
----------------------------------------------------------------------------------------*/
static void allocMoreSymNames(
    uint32 spaceNeeded)
{
    uint32 freeSpace = utAllocatedSymName() - utUsedSymName();

    if((utFreeSymName() << 2) > utUsedSymName()) {
        utCompactSymNames();
        freeSpace = utAllocatedSymName() - utUsedSymName();
    }
    if(freeSpace < spaceNeeded) {
        utRecordResize(utModuleID, 6, utAllocatedSymName(), true);
        utSetAllocatedSymName(utAllocatedSymName() + spaceNeeded - freeSpace +
            (utAllocatedSymName() >> 2));
        utResizeArray(utSyms.Name, utAllocatedSymName());
        utRecordResize(utModuleID, 6, utAllocatedSymName(), false);
    }
}

/*----------------------------------------------------------------------------------------
  Allocate memory for a new Sym.Name array.
----------------------------------------------------------------------------------------*/
void utSymAllocNames(
    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 spaceNeeded = utMax(numNames + usedHeaderSize, freeHeaderSize);

#if defined(DD_DEBUG)
    utAssert(utSymGetNumName(Sym) == 0);
#endif
    if(numNames == 0) {
        return;
    }
    if(freeSpace < spaceNeeded) {
        allocMoreSymNames(spaceNeeded);
    }
    utSymSetNameIndex(Sym, utUsedSymName() + usedHeaderSize);
    utSymSetNumName(Sym, numNames);
    utRecordField(utModuleID, 6, utUsedSymName(), true);
    utRecordArray(utModuleID, 6, utSymGetNameIndex(Sym), numNames, true);
    *(utSym *)(void *)(utSyms.Name + utUsedSymName()) = Sym;
    memset(utSymGetNames(Sym), 0, numNames*elementSize);
    utRecordField(utModuleID, 6, utUsedSymName(), false);
    utRecordArray(utModuleID, 6, utSymGetNameIndex(Sym), numNames, false);
    utSetUsedSymName(utUsedSymName() + spaceNeeded);
}

/*----------------------------------------------------------------------------------------
  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;
    utRecordArray(utModuleID, 6, utUsedSymName(), newSize, true);
    utRecordArray(utModuleID, 6, dataPtr - utSyms.Name, freeHeaderSize, true);
    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;
    utRecordArray(utModuleID, 6, utUsedSymName(), newSize, false);
    utRecordArray(utModuleID, 6, dataPtr - utSyms.Name, freeHeaderSize, false);
    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)
{
    utRecordResize(utModuleID, 10, (utAllocatedDynarray()), true);
    utResizeArray(utDynarrays.ValueIndex, (newSize));
    utRecordResize(utModuleID, 10, (newSize), false);
    utRecordResize(utModuleID, 11, (utAllocatedDynarray()), true);
    utResizeArray(utDynarrays.NumValue, (newSize));
    utRecordResize(utModuleID, 11, (newSize), false);
    utRecordResize(utModuleID, 13, (utAllocatedDynarray()), true);
    utResizeArray(utDynarrays.ValueSize, (newSize));
    utRecordResize(utModuleID, 13, (newSize), false);
    utRecordResize(utModuleID, 14, (utAllocatedDynarray()), true);
    utResizeArray(utDynarrays.UsedValue, (newSize));
    utRecordResize(utModuleID, 14, (newSize), false);
    utRecordResize(utModuleID, 15, (utAllocatedDynarray()), true);
    utResizeArray(utDynarrays.Size, (newSize));
    utRecordResize(utModuleID, 15, (newSize), false);
    utSetAllocatedDynarray(newSize);
}

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

/*----------------------------------------------------------------------------------------
  Compact the Dynarray.Value heap to free memory.