stack allocator and tests

Main.cpp

@@ -20,6 +20,7 @@
 #include "tests/ClockTests.h"
 #include "tests/PNGReaderTests.h"
 #include "tests/BufferTests.h"
+#include "tests/StackAllocatorTests.h"
 #include "wrapper/Framebuffer.h"
 #include "rendering/FileTexture.h"
 
@@ -48,5 +49,6 @@ int main(int argAmount, char** args) {
     ClockTests::test();
     PNGReaderTests::test(args[1]);
     BufferTests::test();
+    StackAllocatorTests::test();
     return 0;
 }

memory/StackAllocator.cpp

@@ -0,0 +1,53 @@
+#include <iostream>
+
+#include "memory/StackAllocator.h"
+
+static constexpr int MAX_BYTES = 50 * 1024 * 1024;
+alignas(16) static char data[MAX_BYTES];
+static int index = 0;
+static int lastIndex = 0;
+
+StackAllocator::Pointer incrementIndex(int inc) {
+    StackAllocator::Pointer p = {lastIndex, index};
+    lastIndex = index;
+    if((inc & 0xF) != 0) {
+        inc = (inc & ~0xF) + 16;
+    }
+    index += inc;
+    return p;
+}
+
+StackAllocator::Pointer StackAllocator::allocate(int bytesPerElement, int& elements) {
+    int bytes = bytesPerElement * elements;
+    if(index + bytes <= MAX_BYTES) {
+        return incrementIndex(bytes);
+    }
+    elements = (MAX_BYTES - index) / bytesPerElement;
+    return incrementIndex(bytesPerElement * elements);
+}
+
+void StackAllocator::free(const Pointer& p) {
+    if(p.pointer > index) {
+        return;
+    }
+    index = p.pointer;
+    lastIndex = p.lastPointer;
+}
+
+int StackAllocator::grow(const Pointer& p, int bytesPerElement, int elements) {
+    if(p.pointer != lastIndex) {
+        return 0;
+    }
+    int bytes = bytesPerElement * elements;
+    if(index + bytes <= MAX_BYTES) {
+        index += bytes;
+        return elements;
+    }
+    elements = (MAX_BYTES - index) / bytesPerElement;
+    index += bytesPerElement * elements;
+    return elements;
+}
+
+void* StackAllocator::get(const Pointer& p) {
+    return data + p.pointer;
+}

memory/StackAllocator.h

@@ -0,0 +1,64 @@
+#ifndef STACKALLOCATOR_H
+#define STACKALLOCATOR_H
+
+namespace StackAllocator {
+
+    struct Pointer {
+        int lastPointer;
+        int pointer;
+    };
+
+    Pointer allocate(int bytesPerElement, int& elements);
+    void free(const Pointer& p);
+    int grow(const Pointer& p, int bytesPerElement, int elements);
+    void* get(const Pointer& p);
+
+    template<typename T>
+    class Array final {
+        int length;
+        Pointer dataPointer;
+
+    public:
+
+        Array(int n) : length(n), dataPointer(StackAllocator::allocate(sizeof (T), length)) {
+            for(int i = 0; i < length; i++) {
+                new (&(*this)[i]) T();
+            }
+        }
+
+        ~Array() {
+            for(int i = 0; i < length; i++) {
+                (*this)[i].~T();
+            }
+            StackAllocator::free(dataPointer);
+        }
+
+        Array(const Array&) = delete;
+        Array& operator=(const Array&) = delete;
+        Array(Array&&) = delete;
+        Array& operator=(Array&&) = delete;
+
+        int getLength() const {
+            return length;
+        }
+
+        int grow(int n) {
+            int add = StackAllocator::grow(dataPointer, sizeof (T), n);
+            for(int i = length; i < length + add; i++) {
+                new (&(*this)[i]) T();
+            }
+            length += add;
+            return add;
+        }
+
+        T& operator[](int index) {
+            return static_cast<T*> (StackAllocator::get(dataPointer))[index];
+        }
+        
+        const T& operator[](int index) const {
+            return static_cast<T*> (StackAllocator::get(dataPointer))[index];
+        }
+    };
+}
+
+#endif

meson.build

@@ -42,7 +42,9 @@ sources = ['Main.cpp',
     'wrapper/WindowOptions.cpp',
     'input/Button.cpp',
     'input/Buttons.cpp',
-    'wrapper/TextureFormat.cpp']
+    'wrapper/TextureFormat.cpp',
+    'memory/StackAllocator.cpp',
+    'tests/StackAllocatorTests.cpp']
 
 glewDep = dependency('glew')
 glfwDep = dependency('glfw3')

tests/StackAllocatorTests.cpp

@@ -0,0 +1,145 @@
+#include "tests/StackAllocatorTests.h"
+#include "tests/Test.h"
+#include "memory/StackAllocator.h"
+
+static void testBasicAllocation(Test& test) {
+    int elements = 6;
+    StackAllocator::Pointer p = StackAllocator::allocate(4, elements);
+    test.checkEqual(0, p.pointer, "first int pointer is 0");
+    test.checkEqual(6, elements, "enough storage for all elements");
+    StackAllocator::free(p);
+}
+
+static void testRepeatedAllocation(Test& test) {
+    int elements[] = {4, 7, 8, 10, 12};
+    StackAllocator::Pointer p[5];
+    for(int i = 0; i < 5; i++) {
+        p[i] = StackAllocator::allocate(4, elements[i]);
+    }
+    test.checkEqual(0, p[0].pointer, "repeated allocation pointer check 1");
+    test.checkEqual(16, p[1].pointer, "repeated allocation pointer check 2");
+    test.checkEqual(48, p[2].pointer, "repeated allocation pointer check 3");
+    test.checkEqual(80, p[3].pointer, "repeated allocation pointer check 4");
+    test.checkEqual(128, p[4].pointer, "repeated allocation pointer check 5");
+    test.checkEqual(4, elements[0], "repeated allocation element check 1");
+    test.checkEqual(7, elements[1], "repeated allocation element check 2");
+    test.checkEqual(8, elements[2], "repeated allocation element check 3");
+    test.checkEqual(10, elements[3], "repeated allocation element check 4");
+    test.checkEqual(12, elements[4], "repeated allocation element check 5");
+    for(int i = 4; i >= 0; i--) {
+        StackAllocator::free(p[i]);
+    }
+}
+
+static void testFree(Test& test) {
+    for(int i = 0; i < 100; i++) {
+        int a = 3;
+        StackAllocator::Pointer ap = StackAllocator::allocate(4, a);
+        test.checkEqual(0, ap.pointer, "free int pointer 1");
+
+        int b = 5;
+        StackAllocator::Pointer bp = StackAllocator::allocate(4, b);
+        test.checkEqual(16, bp.pointer, "free int pointer 2");
+
+        int c = 7;
+        StackAllocator::Pointer cp = StackAllocator::allocate(4, c);
+        test.checkEqual(48, cp.pointer, "free int pointer 3");
+
+        StackAllocator::free(cp);
+        StackAllocator::free(bp);
+        StackAllocator::free(ap);
+    }
+}
+
+static void testOverflow(Test& test) {
+    int elements = 99999999;
+    StackAllocator::Pointer p = StackAllocator::allocate(4, elements);
+    test.checkEqual(true, elements < 99999999, "survives overflow, capped");
+    StackAllocator::free(p);
+}
+
+static void testGrow(Test& test) {
+    for(int k = 0; k < 1000; k++) {
+        int elements = 7;
+        StackAllocator::Pointer p = StackAllocator::allocate(4, elements);
+        for(int i = 0; i < 100; i++) {
+            elements += StackAllocator::grow(p, 4, 4);
+        }
+        test.checkEqual(0, p.pointer, "grow 1");
+        test.checkEqual(407, elements, "grow 2");
+        StackAllocator::free(p);
+    }
+}
+
+static void testNotGrow(Test& test) {
+    int a = 7;
+    StackAllocator::Pointer ap = StackAllocator::allocate(4, a);
+    int b = 7;
+    StackAllocator::Pointer bp = StackAllocator::allocate(4, b);
+    int c = 7;
+    StackAllocator::Pointer cp = StackAllocator::allocate(4, c);
+
+    test.checkEqual(0, StackAllocator::grow(ap, 4, 4), "no growth when the pointer is not the last on the stack 1");
+    test.checkEqual(0, StackAllocator::grow(bp, 4, 4), "no growth when the pointer is not the last on the stack 2");
+    test.checkEqual(4, StackAllocator::grow(cp, 4, 4), "last element on stack can grow 1");
+
+    StackAllocator::free(cp);
+
+    test.checkEqual(0, StackAllocator::grow(ap, 4, 4), "no growth when the pointer is not the last on the stack 3");
+    test.checkEqual(4, StackAllocator::grow(bp, 4, 4), "last element on stack can grow 2");
+
+    StackAllocator::free(bp);
+
+    test.checkEqual(4, StackAllocator::grow(ap, 4, 4), "last element on stack can grow 3");
+
+    StackAllocator::free(ap);
+}
+
+static void testArray(Test& test) {
+    for(int i = 0; i < 100000; i++) {
+        StackAllocator::Array<int> a1(30);
+        StackAllocator::Array<int> a2(50);
+        StackAllocator::Array<int> a3(70);
+        test.checkEqual(30, a1.getLength(), "free array 1");
+        test.checkEqual(50, a2.getLength(), "free array 2");
+        test.checkEqual(70, a3.getLength(), "free array 3");
+    }
+}
+
+static void testArrayGrow(Test& test) {
+    StackAllocator::Array<int> a(700);
+    for(int i = 0; i < 100; i++) {
+        a.grow(2000);
+    }
+    test.checkEqual(200700, a.getLength(), "array grow");
+}
+
+static void testArrayNotGrow(Test& test) {
+    StackAllocator::Array<int> a(7);
+    {
+        StackAllocator::Array<int> b(7);
+        {
+            StackAllocator::Array<int> c(7);
+            test.checkEqual(0, a.grow(4), "no growth when the pointer is not the last on the stack 1");
+            test.checkEqual(0, b.grow(4), "no growth when the pointer is not the last on the stack 2");
+            test.checkEqual(4, c.grow(4), "last element on stack can grow 1");
+        }
+        test.checkEqual(0, a.grow(4), "no growth when the pointer is not the last on the stack 3");
+        test.checkEqual(4, b.grow(4), "last element on stack can grow 2");
+    }
+    test.checkEqual(4, a.grow(4), "last element on stack can grow 3");
+}
+
+void StackAllocatorTests::test() {
+    Test test("StackAllocator");
+    testBasicAllocation(test);
+    testRepeatedAllocation(test);
+    testFree(test);
+    testOverflow(test);
+    testGrow(test);
+    testNotGrow(test);
+    testArray(test);
+    testArrayGrow(test);
+    testArrayNotGrow(test);
+    test.finalize();
+}

tests/StackAllocatorTests.h

@@ -0,0 +1,8 @@
+#ifndef STACKALLOCATORTESTS_H
+#define STACKALLOCATORTESTS_H
+
+namespace StackAllocatorTests {
+    void test();
+}
+
+#endif