dvgenc.c

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

        "    while(fromPtr < %0%1s.%2 + %0Used%1%2()) {\n"
        "        %1 = *(%3%1 *)(void *)fromPtr;\n"
        "        if(%1 != %3%1Null) {\n"
        "            /* Need to move it to toPtr */\n"
        "            size = utMax(%0%1GetNum%2(%1) + usedHeaderSize, freeHeaderSize);\n",
        dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property), dvClassGetPrefix(theClass),
        dvPropertyGetTypeName(property));
    if(dvClassUndo(theClass)) {
        dvWrtemp(dvFile,
            "            utRecordArray(%0ModuleID, %3, toPtr - %0%1s.%2, size, true);\n",
            dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property),
            dvPropertyGetID(property));
    }
    dvWrtemp(dvFile, 
        "            memmove((void *)toPtr, (void *)fromPtr, size*elementSize);\n");
    if(dvClassRedo(theClass)) {
        dvWrtemp(dvFile,
            "            utRecordArray(%0ModuleID, %3, toPtr - %0%1s.%2, size, false);\n",
            dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property),
            dvPropertyGetID(property));
    }
    dvWrtemp(dvFile, 
        "            %0%1Set%2Index(%1, toPtr - %0%1s.%2 + usedHeaderSize);\n"
        "            toPtr += size;\n"
        "        } else {\n"
        "            /* Just skip it */\n"
        "            size = *(uint32 *)(void *)(((%3%1 *)(void *)fromPtr) + 1);\n"
        "        }\n"
        "        fromPtr += size;\n"
        "    }\n"
        "    %0SetUsed%1%2(toPtr - %0%1s.%2);\n"
        "    %0SetFree%1%2(0);\n"
        "}\n\n",
        dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property), dvClassGetPrefix(theClass));
}

/*--------------------------------------------------------------------------------------------------
  Write a function to compact and/or allocate more space on the property heap.
--------------------------------------------------------------------------------------------------*/
static void writeArrayAllocMore(
    dvProperty property)
{
    dvClass theClass = dvPropertyGetClass(property);

    dvWrtemp(dvFile, 
        "/*----------------------------------------------------------------------------------------\n"
        "  Allocate more memory for the %1.%2 heap.\n"
        "----------------------------------------------------------------------------------------*/\n"
        "static void allocMore%1%2s(\n"
        "    uint32 spaceNeeded)\n"
        "{\n"
        "    uint32 freeSpace = %0Allocated%1%2() - %0Used%1%2();\n"
        "\n"
        "    if((%0Free%1%2() << 2) > %0Used%1%2()) {\n"
        "        %0Compact%1%2s();\n"
        "        freeSpace = %0Allocated%1%2() - %0Used%1%2();\n"
        "    }\n"
        "    if(freeSpace < spaceNeeded) {\n",
        dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property), dvClassGetPrefix(theClass),
        dvPropertyGetTypeName(property));
    if(dvClassUndo(theClass)) {
        dvWrtemp(dvFile, 
            "        utRecordResize(%0ModuleID, %3, %0Allocated%1%2(), true);\n",
            dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property),
            utSprintf("%u", dvPropertyGetFieldNumber(property)));
    }
    dvWrtemp(dvFile,
        "        %0SetAllocated%1%2(%0Allocated%1%2() + spaceNeeded - freeSpace +\n"
        "            (%0Allocated%1%2() >> 1));\n"
        "        utResizeArray(%0%1s.%2, %0Allocated%1%2());\n",
        dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property));
    if(dvClassRedo(theClass)) {
        dvWrtemp(dvFile, 
            "        utRecordResize(%0ModuleID, %3, %0Allocated%1%2(), false);\n",
            dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property),
            utSprintf("%u", dvPropertyGetFieldNumber(property)));
    }
    dvWrtemp(dvFile, 
        "    }\n"
        "}\n\n");
}

/*--------------------------------------------------------------------------------------------------
  Write a function to allocate the requested space for the array.  The request is always placed
  at the end of the heap, but if the ammount of free memory withing the heap is > 25%, then we
  compact the heap first.
--------------------------------------------------------------------------------------------------*/
static void writeArrayAlloc(
    dvProperty property)
{
    dvClass theClass = dvPropertyGetClass(property);

    dvWrtemp(dvFile, 
        "/*----------------------------------------------------------------------------------------\n"
        "  Allocate memory for a new %1.%2 array.\n"
        "----------------------------------------------------------------------------------------*/\n"
        "void %0%1Alloc%2s(\n"
        "    %3%1 %1,\n"
        "    uint32 num%2s)\n"
        "{\n"
        "    uint32 freeSpace = %0Allocated%1%2() - %0Used%1%2();\n"
        "    uint32 elementSize = sizeof(%4);\n"
        "    uint32 usedHeaderSize = (sizeof(%3%1) + elementSize - 1)/elementSize;\n"
        "    uint32 freeHeaderSize = (sizeof(%3%1) + sizeof(uint32) + elementSize - 1)/elementSize;\n"
        "    uint32 spaceNeeded = utMax(num%2s + usedHeaderSize, freeHeaderSize);\n"
        "\n"
        "#if defined(DD_DEBUG)\n"
        "    utAssert(%0%1GetNum%2(%1) == 0);\n"
        "#endif\n"
        "    if(num%2s == 0) {\n"
        "        return;\n"
        "    }\n"
        "    if(freeSpace < spaceNeeded) {\n"
        "        allocMore%1%2s(spaceNeeded);\n"
        "    }\n"
        "    %0%1Set%2Index(%1, %0Used%1%2() + usedHeaderSize);\n"
        "    %0%1SetNum%2(%1, num%2s);\n",
        dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property), dvClassGetPrefix(theClass),
        dvPropertyGetTypeName(property));
    if(dvClassUndo(theClass)) {
        dvWrtemp(dvFile,
            "    utRecordArray(%0ModuleID, %3, %0Used%1%2(), num%2s + usedHeaderSize, true);\n",
            dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property),
            dvPropertyGetID(property));
    }
    dvWrtemp(dvFile,
        "    *(%3%1 *)(void *)(%0%1s.%2 + %0Used%1%2()) = %1;\n"
        "    memset(%0%1Get%2s(%1), %4, num%2s*elementSize);\n",
        dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property), dvClassGetPrefix(theClass),
        dvPropertyFindInitValue(property));
    if(dvClassRedo(theClass)) {
        dvWrtemp(dvFile,
            "    utRecordArray(%0ModuleID, %3, %0Used%1%2(), num%2s + usedHeaderSize, false);\n",
            dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property),
            dvPropertyGetID(property));
    }
    dvWrtemp(dvFile,
        "    %0SetUsed%1%2(%0Used%1%2() + spaceNeeded);\n"
        "}\n\n",
        dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property));
    dvWrtemp(dvFile, 
        "/*----------------------------------------------------------------------------------------\n"
        "  Wrapper around %0%1Get%2s for the database manager.\n"
        "----------------------------------------------------------------------------------------*/\n"
        "static void *get%1%2s(\n"
        "    uint64 objectNumber,\n"
        "    uint32 *numValues)\n"
        "{\n"
        "    %3%1 %1 = %3Index2%1(objectNumber);\n"
        "\n"
        "    *numValues = %0%1GetNum%2(%1);\n"
        "    return %0%1Get%2s(%1);\n"
        "}\n"
        "\n"
        "/*----------------------------------------------------------------------------------------\n"
        "  Wrapper around %0%1Alloc%2s for the database manager.\n"
        "----------------------------------------------------------------------------------------*/\n"
        "static void *alloc%1%2s(\n"
        "    uint64 objectNumber,\n"
        "    uint32 numValues)\n"
        "{\n"
        "    %3%1 %1 = %3Index2%1(objectNumber);\n"
        "\n"
        "    %0%1Set%2Index(%1, 0);\n"
        "    %0%1SetNum%2(%1, 0);\n"
        "    if(numValues == 0) {\n"
        "        return NULL;\n"
        "    }\n"
        "    %0%1Alloc%2s(%1, numValues);\n"
        "    return %0%1Get%2s(%1);\n"
        "}\n\n",
        dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property), dvClassGetPrefix(theClass));
}

/*--------------------------------------------------------------------------------------------------
  Write a function to free a property array.
--------------------------------------------------------------------------------------------------*/
static void writeArrayFree(
    dvProperty property)
{
    dvClass theClass = dvPropertyGetClass(property);

    dvWrtemp(dvFile, 
        "/*----------------------------------------------------------------------------------------\n"
        "  Free memory used by the %1.%2 array.\n"
        "----------------------------------------------------------------------------------------*/\n"
        "void %0%1Free%2s(\n"
        "    %3%1 %1)\n"
        "{\n"
        "    uint32 elementSize = sizeof(%4);\n"
        "    uint32 usedHeaderSize = (sizeof(%3%1) + elementSize - 1)/elementSize;\n"
        "    uint32 freeHeaderSize = (sizeof(%3%1) + sizeof(uint32) + elementSize - 1)/elementSize;\n"
        "    uint32 size = utMax(%0%1GetNum%2(%1) + usedHeaderSize, freeHeaderSize);\n"
        "    %4 *dataPtr = %0%1Get%2s(%1) - usedHeaderSize;\n"
        "\n"
        "    if(%0%1GetNum%2(%1) == 0) {\n"
        "        return;\n"
        "    }\n",
        dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property), dvClassGetPrefix(theClass),
        dvPropertyGetTypeName(property));
    if(dvClassUndo(theClass)) {
        dvWrtemp(dvFile,
            "    utRecordArray(%0ModuleID, %3, dataPtr - %0%1s.%2, freeHeaderSize, true);\n",
            dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property),
            dvPropertyGetID(property));
    }
    dvWrtemp(dvFile, 
        "    *(%1%0 *)(void *)(dataPtr) = %1%0Null;\n"
        "    *(uint32 *)(void *)(((%1%0 *)(void *)dataPtr) + 1) = size;\n",
        dvClassGetName(theClass), dvClassGetPrefix(theClass));
    if(dvClassRedo(theClass)) {
        dvWrtemp(dvFile,
            "    utRecordArray(%0ModuleID, %3, dataPtr - %0%1s.%2, freeHeaderSize, false);\n",
            dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property),
            dvPropertyGetID(property));
    }
    dvWrtemp(dvFile, 
        "    %0%1SetNum%2(%1, 0);\n"
        "    %0SetFree%1%2(%0Free%1%2() + size);\n"
        "}\n\n",
        dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property));
}

/*--------------------------------------------------------------------------------------------------
  Write a function to reallocate a property array.
--------------------------------------------------------------------------------------------------*/
static void writeArrayResize(
    dvProperty property)
{
    dvClass theClass = dvPropertyGetClass(property);

    dvWrtemp(dvFile, 
        "/*----------------------------------------------------------------------------------------\n"
        "  Resize the %1.%2 array.\n"
        "----------------------------------------------------------------------------------------*/\n"
        "void %0%1Resize%2s(\n"
        "    %3%1 %1,\n"
        "    uint32 num%2s)\n"
        "{\n"
        "    uint32 freeSpace = %0Allocated%1%2() - %0Used%1%2();\n"
        "    uint32 elementSize = sizeof(%4);\n"
        "    uint32 usedHeaderSize = (sizeof(%3%1) + elementSize - 1)/elementSize;\n"
        "    uint32 freeHeaderSize = (sizeof(%3%1) + sizeof(uint32) + elementSize - 1)/elementSize;\n"
        "    uint32 newSize = utMax(num%2s + usedHeaderSize, freeHeaderSize);\n"
        "    uint32 oldSize = utMax(%0%1GetNum%2(%1) + usedHeaderSize, freeHeaderSize);\n"
        "    %4 *dataPtr;\n"
        "\n"
        "    if(num%2s == 0) {\n"
        "        if(%0%1GetNum%2(%1) != 0) {\n"
        "            %0%1Free%2s(%1);\n"
        "        };\n"
        "        return;\n"
        "    }\n"
        "    if(%0%1GetNum%2(%1) == 0) {\n"
        "        %0%1Alloc%2s(%1, newSize);\n"
        "        return;\n"
        "    };\n"
        "    if(freeSpace < newSize) {\n"
        "        allocMore%1%2s(newSize);\n"
        "    }\n"
        "    dataPtr = %0%1Get%2s(%1) - usedHeaderSize;\n",
        dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property), dvClassGetPrefix(theClass),
        dvPropertyGetTypeName(property));
    if(dvClassUndo(theClass)) {
        dvWrtemp(dvFile,
            "    utRecordArray(%0ModuleID, %3, %0Used%1%2(), newSize, true);\n"
            "    utRecordArray(%0ModuleID, %3, dataPtr - %0%1s.%2, freeHeaderSize, true);\n",
            dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property),
            dvPropertyGetID(property));
    }
    dvWrtemp(dvFile,
        "    memcpy((void *)(%0%1s.%2 + %0Used%1%2()), dataPtr,\n"
        "        elementSize*utMin(oldSize, newSize));\n"
        "    if(newSize > oldSize) {\n"
        "        memset(%0%1s.%2 + %0Used%1%2() + oldSize, %4,\n"
        "            elementSize*(newSize - oldSize));\n"
        "    }\n"
        "    *(%3%1 *)(void *)dataPtr = %3%1Null;\n"
        "    *(uint32 *)(void *)(((%3%1 *)(void *)dataPtr) + 1) = oldSize;\n",
        dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property), dvClassGetPrefix(theClass),
        dvPropertyFindInitValue(property));
    if(dvClassRedo(theClass)) {
        dvWr