Memory Zones

First draft of memory zone functionality. Can create a zone and allocate
you memory from the zone. Also has the ability to clear zones and to
free. There is no way yet to free anything that has been allocated on
the zones.

CMakeLists.txt

@@ -5,7 +5,7 @@ project(quantum-utils)
 set(quantum-src "./quantum/src/")
 set(test_stuff-src "./test_stuff/src/")
 
-add_library(quantum SHARED ${quantum-src}test.c)
+add_library(quantum SHARED ${quantum-src}memory/zone.c)
 add_executable(test_stuff ${test_stuff-src}main.c)
 
 target_link_libraries(test_stuff quantum)

quantum/src/defines.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <inttypes.h>
+#include <assert.h>
+
+typedef int16_t i16;
+typedef uint16_t u16;
+typedef int32_t i32;
+typedef uint32_t u32;
+typedef int64_t i64;
+typedef uint64_t u64;
+typedef float f32;
+typedef double f64;
+
+static_assert(sizeof(i16) == 2);
+static_assert(sizeof(u16) == 2);
+static_assert(sizeof(i32) == 4);
+static_assert(sizeof(u32) == 4);
+static_assert(sizeof(i64) == 8);
+static_assert(sizeof(u64) == 8);
+static_assert(sizeof(f32) == 4);
+static_assert(sizeof(f64) == 8);
+

quantum/src/memory/zone.c

@@ -0,0 +1,66 @@
+#include <stdlib.h> // malloc() free()
+#include <stdio.h> // printf()
+
+#include "../defines.h"
+#include "zone.h"
+
+typedef struct ZoneHeader {
+  u64 capacity;
+  u64 cur_size;
+} ZoneHeader;
+
+Zone * zoneCreate(size_t sizeBytes) {
+  // First we need to get a block of memory from the OS
+  // This block needs to include the size of what we want to store
+  // plus the size of our ZoneHeader
+  void *mem_block = malloc(sizeBytes + sizeof(ZoneHeader));
+
+  // Now that we have the block let's get the addresses
+  // for where the header is, and the offset where the data starts
+  ZoneHeader *zone_header = (ZoneHeader *)mem_block;
+  Zone *zone_addr = (Zone *)(zone_header + sizeof(ZoneHeader));
+
+  // Initialize the values of the header
+  zone_header->capacity = sizeBytes;
+  zone_header->cur_size = 0;
+
+  return zone_addr;
+}
+
+void * zoneAlloc(Zone *zone, size_t sizeBytes) {
+  ZoneHeader *zone_header = (ZoneHeader *)zone - sizeof(ZoneHeader);
+
+  if (zone_header->cur_size + sizeBytes > zone_header->capacity) {
+    printf("Could not allocate, not enough space.");
+    return NULL;
+  }
+
+  void *new_mem = (char *)zone + zone_header->cur_size;
+
+  zone_header->cur_size += sizeBytes;
+
+  printf("Zone Header Information:\n");
+  printf("Current Size: %u\n", zone_header->cur_size);
+  printf("Total Capacity: %u\n", zone_header->capacity);
+
+  return new_mem;
+}
+
+void zoneClear(Zone *zone) {
+  ZoneHeader *zone_header = (ZoneHeader *)zone - sizeof(ZoneHeader);
+
+  zone_header->cur_size = 0;
+
+  printf("Zone Header Information:\n");
+  printf("Current Size: %u\n", zone_header->cur_size);
+  printf("Total Capacity: %u\n", zone_header->capacity);
+}
+
+void zoneDestroy(Zone *zone) {
+  // First we need to go back to the beginning of the header as we returned
+  // an offset for the user to use
+  void *del_mem = (ZoneHeader *)zone - sizeof(ZoneHeader);
+
+  // Free the memory
+  free(del_mem);
+}

quantum/src/memory/zone.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <stddef.h>   // size_t definition
+
+#include "../defines.h"
+
+typedef struct _Zone Zone;
+
+Zone * zoneCreate(size_t sizeBytes);
+void * zoneAlloc(Zone *zone, size_t sizeBytes);
+void zoneClear(Zone *zone);
+void zoneDestroy(Zone *zone);
+

quantum/src/test.c

@@ -1,5 +0,0 @@
-#include <stdio.h>
-
-#include "test.h"
-
-void hello_quantum() { printf("Hello from Quantum!\n"); }

quantum/src/test.h

@@ -1 +0,0 @@
-void hello_quantum();

test_stuff/src/main.c

@@ -1,7 +1,30 @@
-#include <test.h>
+#include <defines.h>
+#include <memory/zone.h>
+#include <stdio.h>
 
 int main() {
-  hello_quantum();
+  printf("Size of i16: %i\n", sizeof(i16));
+  printf("Size of u16: %i\n", sizeof(u16));
+  printf("Size of i32: %i\n", sizeof(i32));
+  printf("Size of u32: %i\n", sizeof(u32));
+  printf("Size of i64: %i\n", sizeof(i64));
+  printf("Size of u64: %i\n", sizeof(u64));
+  printf("Size of f32: %i\n", sizeof(f32));
+  printf("Size of f64: %i\n", sizeof(f64));
+  
+  printf("\nCreating new zone 4K in size...\n");
+  Zone *test_zone = zoneCreate(4096);
+
+  void *test_alloc = zoneAlloc(test_zone, 4);
+  void *test_alloc2 = zoneAlloc(test_zone, 4);
+
+  printf("Address of test_zone: %p\n", (void *)test_zone);
+  printf("Address of test_alloc: %p\n", test_alloc);
+  printf("Address of test_alloc2: %p\n", test_alloc2);
+
+  zoneClear(test_zone);
+
+  zoneDestroy(test_zone);
 
   return 0;
 }