slab: integrate slab experiment, replace spalloc

Author: tyler569

kernel/CMakeLists.txt

@@ -60,7 +60,7 @@ add_executable(nightingale_kernel
     random.c
     ringbuf.c
     signal.c
-    spalloc.c
+    slab.c
     spin.c
     string.c
     sync_testbed.c

kernel/include/ng/slab.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <list.h>
+
+struct slab_cache {
+	list slabs;
+	size_t object_size;
+	size_t requested_size;
+};
+
+void slab_cache_init(struct slab_cache *cache, size_t requested_size);
+
+void *slab_alloc(struct slab_cache *cache);
+void slab_free(struct slab_cache *cache, void *ptr);
+void validate_page_sizes();

kernel/include/ng/spalloc.h

@@ -0,0 +1,168 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <list.h>
+#include <ng/slab.h>
+#include <ng/vmm.h>
+
+constexpr size_t page_size = 0x1000;
+constexpr size_t waste_percentage = 10;
+
+void *alloc_pages(size_t count) {
+	return vmm_reserve(count * 0x1000);
+}
+
+struct slab_header {
+	struct slab_cache *cache;
+
+	list_node siblings;
+
+	void *base;
+	size_t size;
+
+	void *first_free;
+
+	size_t object_count;
+	size_t object_slots;
+};
+
+// objects absolutely must be stored as 8 bytes or larger for the free list
+// anything larger than 8 bytes will store as a multiple of 16 for alignment
+static size_t stored_size(size_t object_size) {
+	if (object_size <= 8)
+		return 8;
+	else
+		return (object_size + 15) & ~15;
+}
+
+// figure out how many pages we need per slab in order to not waste more than
+// `waste_percentage` % of the allocated pages
+static size_t pages_for_size(size_t object_size) {
+	for (size_t pages = 1;; pages++) {
+		size_t region_size = pages * page_size;
+		size_t available_size = region_size - sizeof(struct slab_header);
+		if ((available_size % object_size) * 100 / region_size
+			< waste_percentage)
+			return pages;
+	}
+}
+
+static size_t objects_per_slab(size_t object_size, size_t pages) {
+	return (pages * page_size - sizeof(struct slab_header)) / object_size;
+}
+
+static void *slab_object_ptr(struct slab_header *slab, size_t n) {
+	size_t object_size = slab->cache->object_size;
+	size_t object_count = slab->object_slots;
+
+	if (n >= object_count)
+		return nullptr;
+
+	return slab->base + object_size * n;
+}
+
+static bool slab_contains_ptr(struct slab_header *slab, void *ptr) {
+	return ptr >= slab->base && ptr < (void *)slab;
+}
+
+static struct slab_header *alloc_slab(struct slab_cache *cache) {
+	size_t pages = pages_for_size(cache->object_size);
+	size_t objects = objects_per_slab(cache->object_size, pages);
+
+	void *slab = alloc_pages(pages);
+	if (!slab)
+		return nullptr;
+
+	// header is placed at the _end_ of the allocated region
+	struct slab_header *header
+		= slab + (pages * page_size) - sizeof(struct slab_header);
+	memset(header, 0, sizeof(struct slab_header));
+
+	header->base = slab;
+	header->size = pages * page_size;
+	header->object_slots = objects;
+	header->cache = cache;
+	list_append(&cache->slabs, &header->siblings);
+
+	// set up object free list
+	for (size_t o = 0; o < objects - 1; o++) {
+		*(void **)slab_object_ptr(header, o) = slab_object_ptr(header, o + 1);
+	}
+	*(void **)slab_object_ptr(header, objects - 1) = nullptr;
+
+	header->first_free = slab;
+
+	return header;
+}
+
+static void *alloc_object(struct slab_header *slab) {
+	if (slab->object_count == slab->object_slots) {
+		return nullptr;
+	}
+
+	void *object = slab->first_free;
+	slab->first_free = *(void **)slab->first_free;
+	slab->object_count += 1;
+	return object;
+}
+
+static void free_object(struct slab_header *slab, void *ptr) {
+	assert(slab_contains_ptr(slab, ptr));
+
+	*(void **)ptr = slab->first_free;
+	slab->first_free = ptr;
+	slab->object_count -= 1;
+}
+
+void *slab_alloc(struct slab_cache *cache) {
+	void *object = nullptr;
+
+	list_for_each (&cache->slabs) {
+		struct slab_header *slab
+			= container_of(struct slab_header, siblings, it);
+		if ((object = alloc_object(slab)))
+			return object;
+	}
+
+	struct slab_header *new_slab = alloc_slab(cache);
+	if (new_slab)
+		return alloc_object(new_slab);
+	else
+		return nullptr;
+}
+
+void slab_free(struct slab_cache *cache, void *ptr) {
+	list_for_each (&cache->slabs) {
+		struct slab_header *slab
+			= container_of(struct slab_header, siblings, it);
+		if (slab_contains_ptr(slab, ptr)) {
+			free_object(slab, ptr);
+			return;
+		}
+	}
+
+	assert(0);
+}
+
+void slab_cache_init(struct slab_cache *cache, size_t requested_size) {
+	cache->requested_size = requested_size;
+	cache->object_size = stored_size(requested_size);
+	list_init(&cache->slabs);
+}
+
+void validate_page_sizes() {
+	printf("size\tpages\tobjects\n");
+	for (size_t i = 3; i < 15; i++) {
+		size_t o = (1 << i);
+		size_t p = pages_for_size(o);
+		size_t n = objects_per_slab(o, p);
+		printf("%zu\t%zu\t%zu\n", o, p, n);
+
+		o = (1 << i) + (1 << (i - 1));
+		p = pages_for_size(o);
+		n = objects_per_slab(o, p);
+		printf("%zu\t%zu\t%zu\n", o, p, n);
+	}
+}

kernel/slab.c

@@ -1,6 +1,5 @@
 #include <assert.h>
 #include <ng/cpu.h>
-#include <ng/spalloc.h>
 #include <ng/tests.h>
 #include <ng/thread.h>
 
@@ -12,37 +11,6 @@ void run_sync_tests();
 	kthread_exit();
 }
 
-void run_spalloc_test() {
-	// validate spalloc working
-	struct testing {
-		int a, b, c, d, e, f, g, h;
-	};
-	struct spalloc foobar;
-	sp_init(&foobar, struct testing);
-
-	struct testing *first = sp_alloc(&foobar);
-	assert(first == foobar.region);
-	first->a = 10;
-
-	struct testing *second = sp_alloc(&foobar);
-	assert(second == sp_at(&foobar, 1));
-	second->a = 11;
-
-	assert(first->a == 10);
-
-	first->g = 1;
-	sp_free(&foobar, first);
-	assert(first->g != 1); // poison
-	assert(second->a == 11);
-
-	struct testing *re_first = sp_alloc(&foobar);
-	assert(re_first == first);
-
-	assert(foobar.capacity == 0x10000);
-	assert(foobar.count == 2);
-}
-
 void run_all_tests() {
-	run_spalloc_test();
 	kthread_create(test_kernel_thread, "get a cat");
 }

kernel/spalloc.c

@@ -1,7 +1,7 @@
 #include <assert.h>
 #include <ng/fs.h>
 #include <ng/irq.h>
-#include <ng/spalloc.h>
+#include <ng/slab.h>
 #include <ng/sync.h>
 #include <ng/timer.h>
 #include <ng/x86/pit.h>
@@ -13,7 +13,7 @@
 uint64_t kernel_timer = 0;
 static long long last_tsc;
 static long long tsc_delta;
-struct spalloc timer_pool;
+struct slab_cache timer_pool;
 list timer_q = LIST_INIT(timer_q);
 spinlock_t timer_q_lock;
 
@@ -41,7 +41,7 @@ struct timer_event {
 };
 
 void timer_init() {
-	sp_init(&timer_pool, struct timer_event);
+	slab_cache_init(&timer_pool, sizeof(struct timer_event));
 	irq_install(0, timer_handler, nullptr);
 }
 
@@ -51,7 +51,7 @@ void assert_consistency(struct timer_event *t) {
 
 struct timer_event *insert_timer_event(uint64_t delta_t, void (*fn)(void *),
 	const char *inserter_name, void *data) {
-	struct timer_event *q = sp_alloc(&timer_pool);
+	struct timer_event *q = slab_alloc(&timer_pool);
 	q->at = kernel_timer + delta_t;
 	q->flags = 0;
 	q->fn = fn;
@@ -84,7 +84,7 @@ void drop_timer_event(struct timer_event *te) {
 	spin_lock(&timer_q_lock);
 	list_remove(&te->node);
 	spin_unlock(&timer_q_lock);
-	sp_free(&timer_pool, te);
+	slab_free(&timer_pool, te);
 }
 
 void timer_procfile(struct file *ofd, void *) {
@@ -118,7 +118,7 @@ void timer_handler(interrupt_frame *r, void *impl) {
 
 		spin_unlock(&timer_q_lock);
 		timer_head->fn(timer_head->data);
-		sp_free(&timer_pool, timer_head);
+		slab_free(&timer_pool, timer_head);
 		spin_lock(&timer_q_lock);
 	}
 	spin_unlock(&timer_q_lock);