Merge pull request 'Memory Zones' (#5) from zones into main

Reviewed-on: #5

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;
 }