dvdatabase.c

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

    return dvModpath2Index(Modpath);
}

/*----------------------------------------------------------------------------------------
  Allocate the field arrays of Modpath.
----------------------------------------------------------------------------------------*/
static void allocModpaths(void)
{
    dvSetAllocatedModpath(2);
    dvSetUsedModpath(0);
    dvModpaths.Root = utNewA(dvRoot, (dvAllocatedModpath()));
    dvModpaths.NextRootModpath = utNewA(dvModpath, (dvAllocatedModpath()));
    dvModpaths.PrevRootModpath = utNewA(dvModpath, (dvAllocatedModpath()));
    dvModpaths.Sym = utNewA(utSym, (dvAllocatedModpath()));
    dvModpaths.NextTableRootModpath = utNewA(dvModpath, (dvAllocatedModpath()));
}

/*----------------------------------------------------------------------------------------
  Realloc the arrays of properties for class Modpath.
----------------------------------------------------------------------------------------*/
static void reallocModpaths(
    uint32 newSize)
{
    utResizeArray(dvModpaths.Root, (newSize));
    utResizeArray(dvModpaths.NextRootModpath, (newSize));
    utResizeArray(dvModpaths.PrevRootModpath, (newSize));
    utResizeArray(dvModpaths.Sym, (newSize));
    utResizeArray(dvModpaths.NextTableRootModpath, (newSize));
    dvSetAllocatedModpath(newSize);
}

/*----------------------------------------------------------------------------------------
  Allocate more Modpaths.
----------------------------------------------------------------------------------------*/
void dvModpathAllocMore(void)
{
    reallocModpaths(dvAllocatedModpath() + (dvAllocatedModpath() >> 1));
}

#if defined(DD_DEBUG)
/*----------------------------------------------------------------------------------------
  Write out all the fields of an object.
----------------------------------------------------------------------------------------*/
void dvShowModpath(
    dvModpath Modpath)
{
    utDatabaseShowObject("dv", "Modpath", dvModpath2Index(Modpath));
}
#endif

/*----------------------------------------------------------------------------------------
  Default constructor wrapper for the database manager.
----------------------------------------------------------------------------------------*/
static uint64 allocModule(void)
{
    dvModule Module = dvModuleAlloc();

    return dvModule2Index(Module);
}

/*----------------------------------------------------------------------------------------
  Allocate the field arrays of Module.
----------------------------------------------------------------------------------------*/
static void allocModules(void)
{
    dvSetAllocatedModule(2);
    dvSetUsedModule(0);
    dvModules.PrefixSym = utNewA(utSym, (dvAllocatedModule()));
    dvModules.Persistent = utNewA(uint8, (dvAllocatedModule() + 7) >> 3);
    dvModules.UndoRedo = utNewA(uint8, (dvAllocatedModule() + 7) >> 3);
    dvModules.NumFields = utNewA(uint16, (dvAllocatedModule()));
    dvModules.NumClasses = utNewA(uint32, (dvAllocatedModule()));
    dvModules.NumEnums = utNewA(uint32, (dvAllocatedModule()));
    dvModules.NextRootModule = utNewA(dvModule, (dvAllocatedModule()));
    dvModules.PrevRootModule = utNewA(dvModule, (dvAllocatedModule()));
    dvModules.Sym = utNewA(utSym, (dvAllocatedModule()));
    dvModules.NextTableRootModule = utNewA(dvModule, (dvAllocatedModule()));
    dvModules.FirstClass = utNewA(dvClass, (dvAllocatedModule()));
    dvModules.LastClass = utNewA(dvClass, (dvAllocatedModule()));
    dvModules.ClassTableIndex = utNewA(uint32, (dvAllocatedModule()));
    dvModules.NumClassTable = utNewA(uint32, (dvAllocatedModule()));
    dvSetUsedModuleClassTable(0);
    dvSetAllocatedModuleClassTable(2);
    dvSetFreeModuleClassTable(0);
    dvModules.ClassTable = utNewA(dvClass, dvAllocatedModuleClassTable());
    dvModules.NumClass = utNewA(uint32, (dvAllocatedModule()));
    dvModules.FirstEnum = utNewA(dvEnum, (dvAllocatedModule()));
    dvModules.LastEnum = utNewA(dvEnum, (dvAllocatedModule()));
    dvModules.EnumTableIndex = utNewA(uint32, (dvAllocatedModule()));
    dvModules.NumEnumTable = utNewA(uint32, (dvAllocatedModule()));
    dvSetUsedModuleEnumTable(0);
    dvSetAllocatedModuleEnumTable(2);
    dvSetFreeModuleEnumTable(0);
    dvModules.EnumTable = utNewA(dvEnum, dvAllocatedModuleEnumTable());
    dvModules.NumEnum = utNewA(uint32, (dvAllocatedModule()));
    dvModules.FirstTypedef = utNewA(dvTypedef, (dvAllocatedModule()));
    dvModules.LastTypedef = utNewA(dvTypedef, (dvAllocatedModule()));
    dvModules.TypedefTableIndex = utNewA(uint32, (dvAllocatedModule()));
    dvModules.NumTypedefTable = utNewA(uint32, (dvAllocatedModule()));
    dvSetUsedModuleTypedefTable(0);
    dvSetAllocatedModuleTypedefTable(2);
    dvSetFreeModuleTypedefTable(0);
    dvModules.TypedefTable = utNewA(dvTypedef, dvAllocatedModuleTypedefTable());
    dvModules.NumTypedef = utNewA(uint32, (dvAllocatedModule()));
    dvModules.FirstSchema = utNewA(dvSchema, (dvAllocatedModule()));
    dvModules.LastSchema = utNewA(dvSchema, (dvAllocatedModule()));
    dvModules.SchemaTableIndex = utNewA(uint32, (dvAllocatedModule()));
    dvModules.NumSchemaTable = utNewA(uint32, (dvAllocatedModule()));
    dvSetUsedModuleSchemaTable(0);
    dvSetAllocatedModuleSchemaTable(2);
    dvSetFreeModuleSchemaTable(0);
    dvModules.SchemaTable = utNewA(dvSchema, dvAllocatedModuleSchemaTable());
    dvModules.NumSchema = utNewA(uint32, (dvAllocatedModule()));
    dvModules.FirstImportLink = utNewA(dvLink, (dvAllocatedModule()));
    dvModules.LastImportLink = utNewA(dvLink, (dvAllocatedModule()));
    dvModules.FirstExportLink = utNewA(dvLink, (dvAllocatedModule()));
    dvModules.LastExportLink = utNewA(dvLink, (dvAllocatedModule()));
}

/*----------------------------------------------------------------------------------------
  Realloc the arrays of properties for class Module.
----------------------------------------------------------------------------------------*/
static void reallocModules(
    uint32 newSize)
{
    utResizeArray(dvModules.PrefixSym, (newSize));
    utResizeArray(dvModules.Persistent, (newSize + 7) >> 3);
    utResizeArray(dvModules.UndoRedo, (newSize + 7) >> 3);
    utResizeArray(dvModules.NumFields, (newSize));
    utResizeArray(dvModules.NumClasses, (newSize));
    utResizeArray(dvModules.NumEnums, (newSize));
    utResizeArray(dvModules.NextRootModule, (newSize));
    utResizeArray(dvModules.PrevRootModule, (newSize));
    utResizeArray(dvModules.Sym, (newSize));
    utResizeArray(dvModules.NextTableRootModule, (newSize));
    utResizeArray(dvModules.FirstClass, (newSize));
    utResizeArray(dvModules.LastClass, (newSize));
    utResizeArray(dvModules.ClassTableIndex, (newSize));
    utResizeArray(dvModules.NumClassTable, (newSize));
    utResizeArray(dvModules.NumClass, (newSize));
    utResizeArray(dvModules.FirstEnum, (newSize));
    utResizeArray(dvModules.LastEnum, (newSize));
    utResizeArray(dvModules.EnumTableIndex, (newSize));
    utResizeArray(dvModules.NumEnumTable, (newSize));
    utResizeArray(dvModules.NumEnum, (newSize));
    utResizeArray(dvModules.FirstTypedef, (newSize));
    utResizeArray(dvModules.LastTypedef, (newSize));
    utResizeArray(dvModules.TypedefTableIndex, (newSize));
    utResizeArray(dvModules.NumTypedefTable, (newSize));
    utResizeArray(dvModules.NumTypedef, (newSize));
    utResizeArray(dvModules.FirstSchema, (newSize));
    utResizeArray(dvModules.LastSchema, (newSize));
    utResizeArray(dvModules.SchemaTableIndex, (newSize));
    utResizeArray(dvModules.NumSchemaTable, (newSize));
    utResizeArray(dvModules.NumSchema, (newSize));
    utResizeArray(dvModules.FirstImportLink, (newSize));
    utResizeArray(dvModules.LastImportLink, (newSize));
    utResizeArray(dvModules.FirstExportLink, (newSize));
    utResizeArray(dvModules.LastExportLink, (newSize));
    dvSetAllocatedModule(newSize);
}

/*----------------------------------------------------------------------------------------
  Allocate more Modules.
----------------------------------------------------------------------------------------*/
void dvModuleAllocMore(void)
{
    reallocModules(dvAllocatedModule() + (dvAllocatedModule() >> 1));
}

/*----------------------------------------------------------------------------------------
  Compact the Module.ClassTable heap to free memory.
----------------------------------------------------------------------------------------*/
void dvCompactModuleClassTables(void)
{
    uint32 elementSize = sizeof(dvClass);
    uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
    dvClass *toPtr = dvModules.ClassTable;
    dvClass *fromPtr = toPtr;
    dvModule Module;
    uint32 size;

    while(fromPtr < dvModules.ClassTable + dvUsedModuleClassTable()) {
        Module = *(dvModule *)(void *)fromPtr;
        if(Module != dvModuleNull) {
            /* Need to move it to toPtr */
            size = utMax(dvModuleGetNumClassTable(Module) + usedHeaderSize, freeHeaderSize);
            memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
            dvModuleSetClassTableIndex(Module, toPtr - dvModules.ClassTable + usedHeaderSize);
            toPtr += size;
        } else {
            /* Just skip it */
            size = *(uint32 *)(void *)(((dvModule *)(void *)fromPtr) + 1);
        }
        fromPtr += size;
    }
    dvSetUsedModuleClassTable(toPtr - dvModules.ClassTable);
    dvSetFreeModuleClassTable(0);
}

/*----------------------------------------------------------------------------------------
  Allocate more memory for the Module.ClassTable heap.
----------------------------------------------------------------------------------------*/
static void allocMoreModuleClassTables(
    uint32 spaceNeeded)
{
    uint32 freeSpace = dvAllocatedModuleClassTable() - dvUsedModuleClassTable();

    if((dvFreeModuleClassTable() << 2) > dvUsedModuleClassTable()) {
        dvCompactModuleClassTables();
        freeSpace = dvAllocatedModuleClassTable() - dvUsedModuleClassTable();
    }
    if(freeSpace < spaceNeeded) {
        dvSetAllocatedModuleClassTable(dvAllocatedModuleClassTable() + spaceNeeded - freeSpace +
            (dvAllocatedModuleClassTable() >> 2));
        utResizeArray(dvModules.ClassTable, dvAllocatedModuleClassTable());
    }
}

/*----------------------------------------------------------------------------------------
  Allocate memory for a new Module.ClassTable array.
----------------------------------------------------------------------------------------*/
void dvModuleAllocClassTables(
    dvModule Module,
    uint32 numClassTables)
{
    uint32 freeSpace = dvAllocatedModuleClassTable() - dvUsedModuleClassTable();
    uint32 elementSize = sizeof(dvClass);
    uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 spaceNeeded = utMax(numClassTables + usedHeaderSize, freeHeaderSize);

#if defined(DD_DEBUG)
    utAssert(dvModuleGetNumClassTable(Module) == 0);
#endif
    if(numClassTables == 0) {
        return;
    }
    if(freeSpace < spaceNeeded) {
        allocMoreModuleClassTables(spaceNeeded);
    }
    dvModuleSetClassTableIndex(Module, dvUsedModuleClassTable() + usedHeaderSize);
    dvModuleSetNumClassTable(Module, numClassTables);
    *(dvModule *)(void *)(dvModules.ClassTable + dvUsedModuleClassTable()) = Module;
    memset(dvModuleGetClassTables(Module), 0xff, numClassTables*elementSize);
    dvSetUsedModuleClassTable(dvUsedModuleClassTable() + spaceNeeded);
}

/*----------------------------------------------------------------------------------------
  Wrapper around dvModuleGetClassTables for the database manager.
----------------------------------------------------------------------------------------*/
static void *getModuleClassTables(
    uint64 objectNumber,
    uint32 *numValues)
{
    dvModule Module = dvIndex2Module(objectNumber);

    *numValues = dvModuleGetNumClassTable(Module);
    return dvModuleGetClassTables(Module);
}

/*----------------------------------------------------------------------------------------
  Wrapper around dvModuleAllocClassTables for the database manager.
----------------------------------------------------------------------------------------*/
static void *allocModuleClassTables(
    uint64 objectNumber,
    uint32 numValues)
{
    dvModule Module = dvIndex2Module(objectNumber);

    dvModuleSetClassTableIndex(Module, 0);
    dvModuleSetNumClassTable(Module, 0);
    if(numValues == 0) {
        return NULL;
    }
    dvModuleAllocClassTables(Module, numValues);
    return dvModuleGetClassTables(Module);
}

/*----------------------------------------------------------------------------------------
  Free memory used by the Module.ClassTable array.
----------------------------------------------------------------------------------------*/
void dvModuleFreeClassTables(
    dvModule Module)
{
    uint32 elementSize = sizeof(dvClass);
    uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 size = utMax(dvModuleGetNumClassTable(Module) + usedHeaderSize, freeHeaderSize);
    dvClass *dataPtr = dvModuleGetClassTables(Module) - usedHeaderSize;

    if(dvModuleGetNumClassTable(Module) == 0) {
        return;
    }
    *(dvModule *)(void *)(dataPtr) = dvModuleNull;
    *(uint32 *)(void *)(((dvModule *)(void *)dataPtr) + 1) = size;
    dvModuleSetNumClassTable(Module, 0);
    dvSetFreeModuleClassTable(dvFreeModuleClassTable() + size);
}

/*----------------------------------------------------------------------------------------
  Resize the Module.ClassTable array.
----------------------------------------------------------------------------------------*/
void dvModuleResizeClassTables(
    dvModule Module,
    uint32 numClassTables)
{
    uint32 freeSpace = dvAllocatedModuleClassTable() - dvUsedModuleClassTable();
    uint32 elementSize = sizeof(dvClass);
    uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 newSize = utMax(numClassTables + usedHeaderSize, freeHeaderSize);
    uint32 oldSize = utMax(dvModuleGetNumClassTable(Module) + usedHeaderSize, freeHeaderSize);
    dvClass *dataPtr;

    if(numClassTables == 0) {
        if(dvModuleGetNumClassTable(Module) != 0) {
            dvModuleFreeClassTables(Module);
        };