dvdatabase.c

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

        return;
    }
    if(dvModuleGetNumClassTable(Module) == 0) {
        dvModuleAllocClassTables(Module, newSize);
        return;
    };
    if(freeSpace < newSize) {
        allocMoreModuleClassTables(newSize);
    }
    dataPtr = dvModuleGetClassTables(Module) - usedHeaderSize;
    memcpy((void *)(dvModules.ClassTable + dvUsedModuleClassTable()), dataPtr,
        elementSize*utMin(oldSize, newSize));
    if(newSize > oldSize) {
        memset(dvModules.ClassTable + dvUsedModuleClassTable() + oldSize, 0xff,
            elementSize*(newSize - oldSize));
    }
    *(dvModule *)(void *)dataPtr = dvModuleNull;
    *(uint32 *)(void *)(((dvModule *)(void *)dataPtr) + 1) = oldSize;
    dvSetFreeModuleClassTable(dvFreeModuleClassTable() + oldSize);
    dvModuleSetClassTableIndex(Module, dvUsedModuleClassTable() + usedHeaderSize);
    dvModuleSetNumClassTable(Module, numClassTables);
    dvSetUsedModuleClassTable(dvUsedModuleClassTable() + newSize);
}

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

    while(fromPtr < dvModules.EnumTable + dvUsedModuleEnumTable()) {
        Module = *(dvModule *)(void *)fromPtr;
        if(Module != dvModuleNull) {
            /* Need to move it to toPtr */
            size = utMax(dvModuleGetNumEnumTable(Module) + usedHeaderSize, freeHeaderSize);
            memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
            dvModuleSetEnumTableIndex(Module, toPtr - dvModules.EnumTable + usedHeaderSize);
            toPtr += size;
        } else {
            /* Just skip it */
            size = *(uint32 *)(void *)(((dvModule *)(void *)fromPtr) + 1);
        }
        fromPtr += size;
    }
    dvSetUsedModuleEnumTable(toPtr - dvModules.EnumTable);
    dvSetFreeModuleEnumTable(0);
}

/*----------------------------------------------------------------------------------------
  Allocate more memory for the Module.EnumTable heap.
----------------------------------------------------------------------------------------*/
static void allocMoreModuleEnumTables(
    uint32 spaceNeeded)
{
    uint32 freeSpace = dvAllocatedModuleEnumTable() - dvUsedModuleEnumTable();

    if((dvFreeModuleEnumTable() << 2) > dvUsedModuleEnumTable()) {
        dvCompactModuleEnumTables();
        freeSpace = dvAllocatedModuleEnumTable() - dvUsedModuleEnumTable();
    }
    if(freeSpace < spaceNeeded) {
        dvSetAllocatedModuleEnumTable(dvAllocatedModuleEnumTable() + spaceNeeded - freeSpace +
            (dvAllocatedModuleEnumTable() >> 2));
        utResizeArray(dvModules.EnumTable, dvAllocatedModuleEnumTable());
    }
}

/*----------------------------------------------------------------------------------------
  Allocate memory for a new Module.EnumTable array.
----------------------------------------------------------------------------------------*/
void dvModuleAllocEnumTables(
    dvModule Module,
    uint32 numEnumTables)
{
    uint32 freeSpace = dvAllocatedModuleEnumTable() - dvUsedModuleEnumTable();
    uint32 elementSize = sizeof(dvEnum);
    uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 spaceNeeded = utMax(numEnumTables + usedHeaderSize, freeHeaderSize);

#if defined(DD_DEBUG)
    utAssert(dvModuleGetNumEnumTable(Module) == 0);
#endif
    if(numEnumTables == 0) {
        return;
    }
    if(freeSpace < spaceNeeded) {
        allocMoreModuleEnumTables(spaceNeeded);
    }
    dvModuleSetEnumTableIndex(Module, dvUsedModuleEnumTable() + usedHeaderSize);
    dvModuleSetNumEnumTable(Module, numEnumTables);
    *(dvModule *)(void *)(dvModules.EnumTable + dvUsedModuleEnumTable()) = Module;
    memset(dvModuleGetEnumTables(Module), 0xff, numEnumTables*elementSize);
    dvSetUsedModuleEnumTable(dvUsedModuleEnumTable() + spaceNeeded);
}

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

    *numValues = dvModuleGetNumEnumTable(Module);
    return dvModuleGetEnumTables(Module);
}

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

    dvModuleSetEnumTableIndex(Module, 0);
    dvModuleSetNumEnumTable(Module, 0);
    if(numValues == 0) {
        return NULL;
    }
    dvModuleAllocEnumTables(Module, numValues);
    return dvModuleGetEnumTables(Module);
}

/*----------------------------------------------------------------------------------------
  Free memory used by the Module.EnumTable array.
----------------------------------------------------------------------------------------*/
void dvModuleFreeEnumTables(
    dvModule Module)
{
    uint32 elementSize = sizeof(dvEnum);
    uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 size = utMax(dvModuleGetNumEnumTable(Module) + usedHeaderSize, freeHeaderSize);
    dvEnum *dataPtr = dvModuleGetEnumTables(Module) - usedHeaderSize;

    if(dvModuleGetNumEnumTable(Module) == 0) {
        return;
    }
    *(dvModule *)(void *)(dataPtr) = dvModuleNull;
    *(uint32 *)(void *)(((dvModule *)(void *)dataPtr) + 1) = size;
    dvModuleSetNumEnumTable(Module, 0);
    dvSetFreeModuleEnumTable(dvFreeModuleEnumTable() + size);
}

/*----------------------------------------------------------------------------------------
  Resize the Module.EnumTable array.
----------------------------------------------------------------------------------------*/
void dvModuleResizeEnumTables(
    dvModule Module,
    uint32 numEnumTables)
{
    uint32 freeSpace = dvAllocatedModuleEnumTable() - dvUsedModuleEnumTable();
    uint32 elementSize = sizeof(dvEnum);
    uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 newSize = utMax(numEnumTables + usedHeaderSize, freeHeaderSize);
    uint32 oldSize = utMax(dvModuleGetNumEnumTable(Module) + usedHeaderSize, freeHeaderSize);
    dvEnum *dataPtr;

    if(numEnumTables == 0) {
        if(dvModuleGetNumEnumTable(Module) != 0) {
            dvModuleFreeEnumTables(Module);
        };
        return;
    }
    if(dvModuleGetNumEnumTable(Module) == 0) {
        dvModuleAllocEnumTables(Module, newSize);
        return;
    };
    if(freeSpace < newSize) {
        allocMoreModuleEnumTables(newSize);
    }
    dataPtr = dvModuleGetEnumTables(Module) - usedHeaderSize;
    memcpy((void *)(dvModules.EnumTable + dvUsedModuleEnumTable()), dataPtr,
        elementSize*utMin(oldSize, newSize));
    if(newSize > oldSize) {
        memset(dvModules.EnumTable + dvUsedModuleEnumTable() + oldSize, 0xff,
            elementSize*(newSize - oldSize));
    }
    *(dvModule *)(void *)dataPtr = dvModuleNull;
    *(uint32 *)(void *)(((dvModule *)(void *)dataPtr) + 1) = oldSize;
    dvSetFreeModuleEnumTable(dvFreeModuleEnumTable() + oldSize);
    dvModuleSetEnumTableIndex(Module, dvUsedModuleEnumTable() + usedHeaderSize);
    dvModuleSetNumEnumTable(Module, numEnumTables);
    dvSetUsedModuleEnumTable(dvUsedModuleEnumTable() + newSize);
}

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

    while(fromPtr < dvModules.TypedefTable + dvUsedModuleTypedefTable()) {
        Module = *(dvModule *)(void *)fromPtr;
        if(Module != dvModuleNull) {
            /* Need to move it to toPtr */
            size = utMax(dvModuleGetNumTypedefTable(Module) + usedHeaderSize, freeHeaderSize);
            memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
            dvModuleSetTypedefTableIndex(Module, toPtr - dvModules.TypedefTable + usedHeaderSize);
            toPtr += size;
        } else {
            /* Just skip it */
            size = *(uint32 *)(void *)(((dvModule *)(void *)fromPtr) + 1);
        }
        fromPtr += size;
    }
    dvSetUsedModuleTypedefTable(toPtr - dvModules.TypedefTable);
    dvSetFreeModuleTypedefTable(0);
}

/*----------------------------------------------------------------------------------------
  Allocate more memory for the Module.TypedefTable heap.
----------------------------------------------------------------------------------------*/
static void allocMoreModuleTypedefTables(
    uint32 spaceNeeded)
{
    uint32 freeSpace = dvAllocatedModuleTypedefTable() - dvUsedModuleTypedefTable();

    if((dvFreeModuleTypedefTable() << 2) > dvUsedModuleTypedefTable()) {
        dvCompactModuleTypedefTables();
        freeSpace = dvAllocatedModuleTypedefTable() - dvUsedModuleTypedefTable();
    }
    if(freeSpace < spaceNeeded) {
        dvSetAllocatedModuleTypedefTable(dvAllocatedModuleTypedefTable() + spaceNeeded - freeSpace +
            (dvAllocatedModuleTypedefTable() >> 2));
        utResizeArray(dvModules.TypedefTable, dvAllocatedModuleTypedefTable());
    }
}

/*----------------------------------------------------------------------------------------
  Allocate memory for a new Module.TypedefTable array.
----------------------------------------------------------------------------------------*/
void dvModuleAllocTypedefTables(
    dvModule Module,
    uint32 numTypedefTables)
{
    uint32 freeSpace = dvAllocatedModuleTypedefTable() - dvUsedModuleTypedefTable();
    uint32 elementSize = sizeof(dvTypedef);
    uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 spaceNeeded = utMax(numTypedefTables + usedHeaderSize, freeHeaderSize);

#if defined(DD_DEBUG)
    utAssert(dvModuleGetNumTypedefTable(Module) == 0);
#endif
    if(numTypedefTables == 0) {
        return;
    }
    if(freeSpace < spaceNeeded) {
        allocMoreModuleTypedefTables(spaceNeeded);
    }
    dvModuleSetTypedefTableIndex(Module, dvUsedModuleTypedefTable() + usedHeaderSize);
    dvModuleSetNumTypedefTable(Module, numTypedefTables);
    *(dvModule *)(void *)(dvModules.TypedefTable + dvUsedModuleTypedefTable()) = Module;
    memset(dvModuleGetTypedefTables(Module), 0xff, numTypedefTables*elementSize);
    dvSetUsedModuleTypedefTable(dvUsedModuleTypedefTable() + spaceNeeded);
}

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

    *numValues = dvModuleGetNumTypedefTable(Module);
    return dvModuleGetTypedefTables(Module);
}

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

    dvModuleSetTypedefTableIndex(Module, 0);
    dvModuleSetNumTypedefTable(Module, 0);
    if(numValues == 0) {
        return NULL;
    }
    dvModuleAllocTypedefTables(Module, numValues);
    return dvModuleGetTypedefTables(Module);
}

/*----------------------------------------------------------------------------------------
  Free memory used by the Module.TypedefTable array.
----------------------------------------------------------------------------------------*/
void dvModuleFreeTypedefTables(
    dvModule Module)
{
    uint32 elementSize = sizeof(dvTypedef);
    uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 size = utMax(dvModuleGetNumTypedefTable(Module) + usedHeaderSize, freeHeaderSize);
    dvTypedef *dataPtr = dvModuleGetTypedefTables(Module) - usedHeaderSize;

    if(dvModuleGetNumTypedefTable(Module) == 0) {