utdatabaseu.c

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

    if((utFreeSymArraySym() << 2) > utUsedSymArraySym()) {
        utCompactSymArraySyms();
        freeSpace = utAllocatedSymArraySym() - utUsedSymArraySym();
    }
    if(freeSpace < spaceNeeded) {
        utRecordResize(utModuleID, 18, utAllocatedSymArraySym(), true);
        utSetAllocatedSymArraySym(utAllocatedSymArraySym() + spaceNeeded - freeSpace +
            (utAllocatedSymArraySym() >> 2));
        utResizeArray(utSymArrays.Sym, utAllocatedSymArraySym());
        utRecordResize(utModuleID, 18, utAllocatedSymArraySym(), false);
    }
}

/*----------------------------------------------------------------------------------------
  Allocate memory for a new SymArray.Sym array.
----------------------------------------------------------------------------------------*/
void utSymArrayAllocSyms(
    utSymArray SymArray,
    uint32 numSyms)
{
    uint32 freeSpace = utAllocatedSymArraySym() - utUsedSymArraySym();
    uint32 elementSize = sizeof(utSym);
    uint32 usedHeaderSize = (sizeof(utSymArray) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(utSymArray) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 spaceNeeded = utMax(numSyms + usedHeaderSize, freeHeaderSize);

#if defined(DD_DEBUG)
    utAssert(utSymArrayGetNumSym(SymArray) == 0);
#endif
    if(numSyms == 0) {
        return;
    }
    if(freeSpace < spaceNeeded) {
        allocMoreSymArraySyms(spaceNeeded);
    }
    utSymArraySetSymIndex(SymArray, utUsedSymArraySym() + usedHeaderSize);
    utSymArraySetNumSym(SymArray, numSyms);
    utRecordField(utModuleID, 18, utUsedSymArraySym(), true);
    utRecordArray(utModuleID, 18, utSymArrayGetSymIndex(SymArray), numSyms, true);
    *(utSymArray *)(void *)(utSymArrays.Sym + utUsedSymArraySym()) = SymArray;
    memset(utSymArrayGetSyms(SymArray), 0xff, numSyms*elementSize);
    utRecordField(utModuleID, 18, utUsedSymArraySym(), false);
    utRecordArray(utModuleID, 18, utSymArrayGetSymIndex(SymArray), numSyms, false);
    utSetUsedSymArraySym(utUsedSymArraySym() + spaceNeeded);
}

/*----------------------------------------------------------------------------------------
  Wrapper around utSymArrayGetSyms for the database manager.
----------------------------------------------------------------------------------------*/
static void *getSymArraySyms(
    uint64 objectNumber,
    uint32 *numValues)
{
    utSymArray SymArray = utIndex2SymArray(objectNumber);

    *numValues = utSymArrayGetNumSym(SymArray);
    return utSymArrayGetSyms(SymArray);
}

/*----------------------------------------------------------------------------------------
  Wrapper around utSymArrayAllocSyms for the database manager.
----------------------------------------------------------------------------------------*/
static void *allocSymArraySyms(
    uint64 objectNumber,
    uint32 numValues)
{
    utSymArray SymArray = utIndex2SymArray(objectNumber);

    utSymArraySetSymIndex(SymArray, 0);
    utSymArraySetNumSym(SymArray, 0);
    if(numValues == 0) {
        return NULL;
    }
    utSymArrayAllocSyms(SymArray, numValues);
    return utSymArrayGetSyms(SymArray);
}

/*----------------------------------------------------------------------------------------
  Free memory used by the SymArray.Sym array.
----------------------------------------------------------------------------------------*/
void utSymArrayFreeSyms(
    utSymArray SymArray)
{
    uint32 elementSize = sizeof(utSym);
    uint32 usedHeaderSize = (sizeof(utSymArray) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(utSymArray) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 size = utMax(utSymArrayGetNumSym(SymArray) + usedHeaderSize, freeHeaderSize);
    utSym *dataPtr = utSymArrayGetSyms(SymArray) - usedHeaderSize;

    if(utSymArrayGetNumSym(SymArray) == 0) {
        return;
    }
    *(utSymArray *)(void *)(dataPtr) = utSymArrayNull;
    *(uint32 *)(void *)(((utSymArray *)(void *)dataPtr) + 1) = size;
    utSymArraySetNumSym(SymArray, 0);
    utSetFreeSymArraySym(utFreeSymArraySym() + size);
}

/*----------------------------------------------------------------------------------------
  Resize the SymArray.Sym array.
----------------------------------------------------------------------------------------*/
void utSymArrayResizeSyms(
    utSymArray SymArray,
    uint32 numSyms)
{
    uint32 freeSpace = utAllocatedSymArraySym() - utUsedSymArraySym();
    uint32 elementSize = sizeof(utSym);
    uint32 usedHeaderSize = (sizeof(utSymArray) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(utSymArray) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 newSize = utMax(numSyms + usedHeaderSize, freeHeaderSize);
    uint32 oldSize = utMax(utSymArrayGetNumSym(SymArray) + usedHeaderSize, freeHeaderSize);
    utSym *dataPtr;

    if(numSyms == 0) {
        if(utSymArrayGetNumSym(SymArray) != 0) {
            utSymArrayFreeSyms(SymArray);
        };
        return;
    }
    if(utSymArrayGetNumSym(SymArray) == 0) {
        utSymArrayAllocSyms(SymArray, newSize);
        return;
    };
    if(freeSpace < newSize) {
        allocMoreSymArraySyms(newSize);
    }
    dataPtr = utSymArrayGetSyms(SymArray) - usedHeaderSize;
    utRecordArray(utModuleID, 18, utUsedSymArraySym(), newSize, true);
    utRecordArray(utModuleID, 18, dataPtr - utSymArrays.Sym, freeHeaderSize, true);
    memcpy((void *)(utSymArrays.Sym + utUsedSymArraySym()), dataPtr,
        elementSize*utMin(oldSize, newSize));
    if(newSize > oldSize) {
        memset(utSymArrays.Sym + utUsedSymArraySym() + oldSize, 0xff,
            elementSize*(newSize - oldSize));
    }
    *(utSymArray *)(void *)dataPtr = utSymArrayNull;
    *(uint32 *)(void *)(((utSymArray *)(void *)dataPtr) + 1) = oldSize;
    utRecordArray(utModuleID, 18, utUsedSymArraySym(), newSize, false);
    utRecordArray(utModuleID, 18, dataPtr - utSymArrays.Sym, freeHeaderSize, false);
    utSetFreeSymArraySym(utFreeSymArraySym() + oldSize);
    utSymArraySetSymIndex(SymArray, utUsedSymArraySym() + usedHeaderSize);
    utSymArraySetNumSym(SymArray, numSyms);
    utSetUsedSymArraySym(utUsedSymArraySym() + newSize);
}

/*----------------------------------------------------------------------------------------
  Add the indexed Sym to the SymArray.
----------------------------------------------------------------------------------------*/
void utSymArrayInsertSym(
    utSymArray SymArray,
    uint32 x,
    utSym _Sym)
{
#if defined(DD_DEBUG)
    if(SymArray == utSymArrayNull) {
        utExit("Non existent SymArray");
    }
#endif
    utSymArraySetiSym(SymArray, x, _Sym);
    utSymSetSymArrayIndex(_Sym, x);
    utSymArraySetUsedSym(SymArray, utMax(utSymArrayGetUsedSym(SymArray), x + 1));
}

/*----------------------------------------------------------------------------------------
  Add the Sym to the end of the SymArraySym array.
----------------------------------------------------------------------------------------*/
void utSymArrayAppendSym(
    utSymArray SymArray,
    utSym _Sym)
{
    uint32 usedSym = utSymArrayGetUsedSym(SymArray);

#if defined(DD_DEBUG)
    if(SymArray == utSymArrayNull) {
        utExit("Non existent SymArray");
    }
#endif
    if(usedSym >= utSymArrayGetNumSym(SymArray)) {
        utSymArrayResizeSyms(SymArray, usedSym + (usedSym << 1) + 1);
    }
    utSymArraySetiSym(SymArray, usedSym, _Sym);
    utSymSetSymArrayIndex(_Sym, usedSym);
    utSymArraySetUsedSym(SymArray, usedSym + 1);
}

/*----------------------------------------------------------------------------------------
  Remove the Sym from the SymArray.
----------------------------------------------------------------------------------------*/
void utSymArrayRemoveSym(
    utSymArray SymArray,
    utSym _Sym)
{
#if defined(DD_DEBUG)
    if(_Sym == utSymNull) {
        utExit("Non-existent Sym");
    }
#endif
    utSymArraySetiSym(SymArray, utSymGetSymArrayIndex(_Sym), utSymNull);
    utSymSetSymArrayIndex(_Sym, UINT32_MAX);
}

#if defined(DD_DEBUG)
/*----------------------------------------------------------------------------------------
  Write out all the fields of an object.
----------------------------------------------------------------------------------------*/
void utShowSymArray(
    utSymArray SymArray)
{
    utDatabaseShowObject("ut", "SymArray", utSymArray2Index(SymArray));
}
#endif

/*----------------------------------------------------------------------------------------
  Free memory used by the ut database.
----------------------------------------------------------------------------------------*/
void utDatabaseStop(void)
{
    utFree(utSymtabs.TableIndex);
    utFree(utSymtabs.NumTable);
    utFree(utSymtabs.Table);
    utFree(utSymtabs.NumSym);
    utFree(utSyms.NameIndex);
    utFree(utSyms.NumName);
    utFree(utSyms.Name);
    utFree(utSyms.HashValue);
    utFree(utSyms.Next);
    utFree(utSyms.SymArrayIndex);
    utFree(utDynarrays.ValueIndex);
    utFree(utDynarrays.NumValue);
    utFree(utDynarrays.Value);
    utFree(utDynarrays.ValueSize);
    utFree(utDynarrays.UsedValue);
    utFree(utDynarrays.Size);
    utFree(utSymArrays.SymIndex);
    utFree(utSymArrays.NumSym);
    utFree(utSymArrays.Sym);
    utFree(utSymArrays.UsedSym);
    utUnregisterModule(utModuleID);
}

/*----------------------------------------------------------------------------------------
  Allocate memory used by the ut database.
----------------------------------------------------------------------------------------*/
void utDatabaseStart(void)
{
    if(!utInitialized()) {
        utStart();
    }
    utRootData.hash = 0xa8be69c1;
    utModuleID = utRegisterModule("ut", utHash(), 4, 20, 0, sizeof(struct utRootType_),
        &utRootData, utDatabaseStart, utDatabaseStop);
    utRegisterClass("Symtab", 4, &utRootData.usedSymtab, &utRootData.allocatedSymtab,
        NULL, 0, 4, allocSymtab, NULL);
    utRegisterField("TableIndex", &utSymtabs.TableIndex, sizeof(uint32), UT_UINT, NULL);
    utSetFieldHidden();
    utRegisterField("NumTable", &utSymtabs.NumTable, sizeof(uint32), UT_UINT, NULL);
    utSetFieldHidden();
    utRegisterField("Table", &utSymtabs.Table, sizeof(utSym), UT_SYM, NULL);
    utRegisterArray(&utRootData.usedSymtabTable, &utRootData.allocatedSymtabTable,
        getSymtabTables, allocSymtabTables);
    utRegisterField("NumSym", &utSymtabs.NumSym, sizeof(uint32), UT_UINT, NULL);
    utRegisterClass("Sym", 6, &utRootData.usedSym, &utRootData.allocatedSym,
        NULL, 4, 4, allocSym, NULL);
    utRegisterField("NameIndex", &utSyms.NameIndex, sizeof(uint32), UT_UINT, NULL);
    utSetFieldHidden();
    utRegisterField("NumName", &utSyms.NumName, sizeof(uint32), UT_UINT, NULL);
    utSetFieldHidden();
    utRegisterField("Name", &utSyms.Name, sizeof(char), UT_CHAR, NULL);
    utRegisterArray(&utRootData.usedSymName, &utRootData.allocatedSymName,
        getSymNames, allocSymNames);
    utRegisterField("HashValue", &utSyms.HashValue, sizeof(uint32), UT_UINT, NULL);
    utRegisterField("Next", &utSyms.Next, sizeof(utSym), UT_POINTER, "Sym");
    utRegisterField("SymArrayIndex", &utSyms.SymArrayIndex, sizeof(uint32), UT_UINT, NULL);
    utRegisterClass("Dynarray", 6, &utRootData.usedDynarray, &utRootData.allocatedDynarray,
        &utRootData.firstFreeDynarray, 10, 4, allocDynarray, destroyDynarray);
    utRegisterField("ValueIndex", &utDynarrays.ValueIndex, sizeof(uint32), UT_UINT, NULL);
    utSetFieldHidden();
    utRegisterField("NumValue", &utDynarrays.NumValue, sizeof(uint32), UT_UINT, NULL);
    utSetFieldHidden();
    utRegisterField("Value", &utDynarrays.Value, sizeof(uint8), UT_UINT, NULL);
    utRegisterArray(&utRootData.usedDynarrayValue, &utRootData.allocatedDynarrayValue,
        getDynarrayValues, allocDynarrayValues);
    utRegisterField("ValueSize", &utDynarrays.ValueSize, sizeof(uint16), UT_UINT, NULL);
    utRegisterField("UsedValue", &utDynarrays.UsedValue, sizeof(uint32), UT_UINT, NULL);
    utRegisterField("Size", &utDynarrays.Size, sizeof(uint32), UT_UINT, NULL);
    utRegisterClass("SymArray", 4, &utRootData.usedSymArray, &utRootData.allocatedSymArray,
        &utRootData.firstFreeSymArray, 16, 4, allocSymArray, destroySymArray);
    utRegisterField("SymIndex", &utSymArrays.SymIndex, sizeof(uint32), UT_UINT, NULL);
    utSetFieldHidden();
    utRegisterField("NumSym", &utSymArrays.NumSym, sizeof(uint32), UT_UINT, NULL);
    utSetFieldHidden();
    utRegisterField("Sym", &utSymArrays.Sym, sizeof(utSym), UT_POINTER, "Sym");
    utRegisterArray(&utRootData.usedSymArraySym, &utRootData.allocatedSymArraySym,
        getSymArraySyms, allocSymArraySyms);
    utRegisterField("UsedSym", &utSymArrays.UsedSym, sizeof(uint32), UT_UINT, NULL);
    allocSymtabs();
    allocSyms();
    allocDynarrays();
    allocSymArrays();
}