_ForgeUser4750044 - SC2 Mapster Forums

Gemini Project - Galaxy Editor dll Injector Aug 3, 2012

_ForgeUser4750044

Join Date: 7/22/2010
Posts: 14
Member Details

Quote from midiway: Go
@nestharus: Go

What are you talking about? Gemini has, in a sense, nothing to do with the Galaxy language, it is not a preprocessor or compiler or text-editor ...

@Frizi: Go

I am quite familiar with them, I use all my string in Unicode format, like L"My String Wooww"

uh huh, Frizi just made it sound like he was updating this and taking over Galaxy or something ;o.

eh nvm then =).

Gemini Project - Galaxy Editor dll Injector Aug 2, 2012

_ForgeUser4750044

Join Date: 7/22/2010
Posts: 14
Member Details

Quote from Frizi: Go
@nestharus: Go

Err... wait. Cool heap allocator implementation, but this is more or less a galaxy library. You can post it as an asset.

but, it'd be best supported in the background of a language so that you have nice syntax with it (treating pointers as arrays/scalars, etc). It's kind of eh to use memory read/write methods :\.

Gemini Project - Galaxy Editor dll Injector Aug 1, 2012

_ForgeUser4750044

Join Date: 7/22/2010
Posts: 14
Member Details

For when you update, I think that the stuff like Galaxy should probably use something more like this for memory allocation/deallocation as it's much faster =).

The array refs in SC2 are relatively useless since they are so static D:.

Could actually do a sizeof thing here, though it could refer to the array size =).

//debug purposes only
void print(string msg) {
    TriggerDebugOutput(1, StringToText(msg), true);
}

static int[9] powers;
static const int MEMORY_SIZE = 8192;
static int[MEMORY_SIZE] memory;
static byte[MEMORY_SIZE/8] deallocatedCollections;

static const int TYPE_INT = 1;

static int allocatedMemory = 0;
static int freedMemory = 0;
static int releasedMemory = 0;

static bool initialized = false;

static bool getDeallocated(int pointer) { return 1 == (deallocatedCollections[pointer/8]/powers[pointer%8])%2; }
static void setDeallocated(int pointer, bool val) {
    //position: pointer/8
    //index: pointer%8
    //number: deallocatedCollections[position]
    //left: number/powers[index + 1]
    //middle: number/powers[index]%2
    //rightSize: powers[index]
    //right: number%rightSize
    //number = (left*2 + BoolToInt(val))*rightSize + right
    deallocatedCollections[pointer/8] = (deallocatedCollections[pointer/8]/powers[pointer%8 + 1]*2 + BoolToInt(val))*powers[pointer%8] + deallocatedCollections[pointer/8]%powers[pointer%8];
}

int read(int pointer) { return memory[pointer - TYPE_INT]; }
void write(int pointer, int value) { memory[pointer - TYPE_INT] = value; }

int getArraySize(int pointer) { return DataTableGetInt(true, "ARR_SIZE" + IntToString(pointer)); }
static void setArraySize(int pointer, int size) { DataTableSetInt(true, "ARR_SIZE" + IntToString(pointer), size); }

static int getMemorySize(int pointer) { return DataTableGetInt(true, "MEM_SIZE" + IntToString(pointer)); }
static void setMemorySize(int pointer, int size) { DataTableSetInt(true, "MEM_SIZE" + IntToString(pointer), size); }

static int getPosition(int pointer) { return DataTableGetInt(true, "HEAP_POSITION" + IntToString(pointer)); }
static int getPointer(int position) { return DataTableGetInt(true, "HEAP_POINTER" + IntToString(position)); }
static void setPosition(int pointer, int position) { DataTableSetInt(true, "HEAP_POSITION" + IntToString(pointer), position); }
static void setPointer(int position, int pointer) { DataTableSetInt(true, "HEAP_POINTER" + IntToString(position), pointer); }

static int getParentPosition(int position) { return position/2; }
static int getLeftPosition(int position) { return position*2; }
static int getRightPosition(int position) { return position*2 + 1; }

static void link(int pointer, int pointerPosition) {
    setPointer(pointerPosition, pointer);
    setPosition(pointer, pointerPosition);
}

static void initialize() {
    if (!initialized) {
        initialized = true;

        powers[0] = 1;
        powers[1] = 2;
        powers[2] = 4;
        powers[3] = 8;
        powers[4] = 16;
        powers[5] = 32;
        powers[6] = 64;
        powers[7] = 128;
        powers[8] = 256;
    } //if
}

//debug purposes only
void printMemory() {
    print("Used  Memory: " + IntToString(allocatedMemory - releasedMemory));
    print("Heap Size: " + IntToString(freedMemory));
}

static void bubbleUp(int pointer) {
    int pointerSize = getMemorySize(pointer);
    int pointerPosition = getPosition(pointer);
    int parentPosition = getParentPosition(pointerPosition);
    int parentPointer = getPointer(parentPosition);

    while (0 != parentPosition && getMemorySize(parentPointer) < pointerSize) {
        link(parentPointer, pointerPosition);

        pointerPosition = parentPosition;
        parentPosition = getParentPosition(pointerPosition);
        parentPointer = getPointer(parentPosition);
    }

    link(pointer, pointerPosition);
}

static void bubbleDown(int pointer) {
    int pointerSize  = getMemorySize(pointer);
    int pointerPosition = getPosition(pointer);

    int leftPosition = getLeftPosition(pointerPosition);
    int rightPosition = getRightPosition(pointerPosition);

    int leftPointer = getPointer(leftPosition);
    int rightPointer = getPointer(rightPosition);

    int leftSize = getMemorySize(leftPointer);
    int rightSize = getMemorySize(rightPointer);

    while ((0 != leftPointer && leftSize > pointerSize) || (0 != rightPointer && rightSize > pointerSize)) {
        if (0 == rightPointer || (0 != leftPointer && leftSize > rightSize)) {
            link(leftPointer, pointerPosition);

            pointerPosition = leftPosition;
        }
        else {
            link(rightPointer, pointerPosition);

            pointerPosition = rightPosition;
        }

        leftPosition = getLeftPosition(pointerPosition);
        rightPosition = getRightPosition(pointerPosition);

        leftPointer = getPointer(leftPosition);
        rightPointer = getPointer(rightPosition);

        leftSize = getMemorySize(leftPointer);
        rightSize = getMemorySize(rightPointer);
    }

    link(pointer, pointerPosition);
}

static void recycle(int pointerPosition) {
    int pointer = getPointer(freedMemory);

    setPointer(freedMemory, 0);

    link(pointer, pointerPosition);

    if (pointerPosition != 1) {
        bubbleUp(pointer);
    } //if

    bubbleDown(pointer);

    freedMemory = freedMemory - 1;
}

static void defragment(int pointer) {
    int pointerPosition = getPosition(pointer);
    int size = getMemorySize(pointer);
    int mergeSize;

    if (0 != pointer && getDeallocated(pointer - 1)) {
        setDeallocated(pointer, false);
        setMemorySize(pointer, 0);

        mergeSize = getMemorySize(pointer - 1);
        TriggerDebugOutput(1, StringToText("(") + IntToText(pointer - mergeSize) + StringToText(" .. ") + IntToText(pointer - 1) + StringToText(") + (") + IntToText(pointer) + StringToText(" .. ") + IntToText(pointer + size - 1) + StringToText(")"), true);
        size = size + mergeSize;

        if (1 < mergeSize) {
            setDeallocated(pointer - 1, false);
            setMemorySize(pointer - 1, 0);
        } //if

        pointer = pointer - mergeSize;

        recycle(getPosition(pointer));
    }

    if (pointer + size < MEMORY_SIZE && getDeallocated(pointer + size)) {
        setDeallocated(pointer + size - 1, false);
        setMemorySize(pointer + size - 1, 0);

        mergeSize = getMemorySize(pointer + size);
        TriggerDebugOutput(1, StringToText("(") + IntToText(pointer) + StringToText(" .. ") + IntToText(pointer + size - 1) + StringToText(") + (") + IntToText(pointer + size) + StringToText(" .. ") + IntToText(pointer + size + mergeSize - 1) + StringToText(")"), true);
        size = size + mergeSize;

        if (1 < mergeSize) {
            setDeallocated(pointer + size, false);
            setMemorySize(pointer + size, 0);
        } //if

        recycle(getPosition(pointer + size));
    }

    setMemorySize(pointer, size);
    setMemorySize(pointer + size - 1, size);

    link(pointer, pointerPosition);

    bubbleUp(pointer);
}

int allocate(int size) {
    int pointer = getPointer(1);
    int memorySize = getMemorySize(pointer);

    int pointerPosition;

    initialize();

    if (0 == freedMemory || memorySize < size) {
        if (allocatedMemory + size >= MEMORY_SIZE) {
            TriggerDebugOutput(1, StringToText("ALLOCATE OVERFLOW"), true);
            return 0;
        } //if

        pointer = allocatedMemory;
        allocatedMemory = allocatedMemory + size;
    } //if
    else {
        setMemorySize(pointer, 0);
        setDeallocated(pointer, false);

        setMemorySize(pointer + size, memorySize - size);
        setMemorySize(pointer + memorySize - 1, memorySize - size);

        if (0 == memorySize - size) {
            recycle(1);

            setDeallocated(pointer + memorySize - 1, false);
        }
        else {
            link(pointer + size, 1);
            setDeallocated(pointer + size, true);

            bubbleDown(pointer + size);
        }

        releasedMemory = releasedMemory - size;
    }

    pointer = pointer + TYPE_INT;
    setArraySize(pointer, size);

    return pointer;
}

void deallocate(int pointer) {
    int size = getArraySize(pointer);

    pointer = pointer - TYPE_INT;
    
    if (0 == size) {
        TriggerDebugOutput(1, StringToText("ATTEMPT TO DEALLOCATE NULL POINTER"), true);
        return;
    } //if

    setMemorySize(pointer, size);
    setArraySize(pointer + TYPE_INT, 0);

    releasedMemory = releasedMemory + size;

    freedMemory = freedMemory + 1;
    link(pointer, freedMemory);
    bubbleUp(pointer);

    setDeallocated(pointer, true);
    setDeallocated(pointer + size - 1, true);

    setMemorySize(pointer + size - 1, size);

    defragment(pointer);
}

Last edited by _ForgeUser4750044: Aug 1, 2012

SC2Mapster

Search results for '_ForgeUser4750044'