Worked on runtime and threadpool

src/runtime.c

@@ -0,0 +1,100 @@
+#include "runtime.h"
+
+#include <sus/hashtable.h>
+#include <sus/hashes.h>
+#include <sus/ivector.h>
+
+#include "thread_pool.h"
+
+typedef struct recurring_callback_t {
+	long period;
+	long phase;
+	system_tick_t callback;
+} recurring_callback_t;
+
+
+
+static long _tick;
+//hashtable_t<long, ivector_t<system_tick_t>*>
+static hashtable_t *_future_callbacks;
+//ivector_t<recurring_callback_t>
+static ivector_t *_recurring_callbacks;
+static thread_pool_t *callback_pool;
+
+
+
+static void register_callback(long delay, system_tick_t callback)
+{
+	long tick = delay + _tick;
+
+	ivector_t *vector = hashtable_get(_future_callbacks, tick);
+	if (!vector) 
+	{
+		vector = ivector_create(sizeof(sizeof(system_tick_t)));
+		hashtable_add(_future_callbacks, tick, vector);
+	}
+
+	ivector_append(vector, callback);
+}
+
+static void handle_callbacks(ivector_t *callbacks)
+{
+	size_t count = ivector_get_count(callbacks);
+	for (size_t i = 0; i < count; ++i)
+	{
+		system_tick_t *tick = ivector_get(callbacks, i);
+		//TODO: Dispatch work
+	}
+}
+
+static void register_recurring_callbacks()
+{
+	size_t count = ivector_get_count(_recurring_callbacks);
+	for (size_t i = 0; i < count; ++i)
+	{
+		recurring_callback_t *callback = ivector_get(_recurring_callbacks, i);
+		long phase = _tick % callback->period;
+
+		if (phase != callback->phase)
+			continue;
+
+		register_callback(callback->period, callback->callback);
+	}
+}
+
+void runtime_init()
+{
+	_tick = 0;
+	_future_callbacks = hashtable_create(hash_ptr, compare_ptr);
+	_recurring_callbacks = ivector_create(sizeof(recurring_callback_t));
+}
+
+void runtime_loop()
+{
+	//Runtime loop
+	//Ticks every 10ms
+	//Systems request X tick delay callbacks
+	//Callbacks executed on separate threads
+
+	//Handle pending callbacks and register recurring
+	ivector_t *callbacks = hashtable_get(_future_callbacks, _tick);
+	if (callbacks)
+	{
+		handle_callbacks(callbacks);
+		hashtable_remove(_future_callbacks, _tick, NULL, NULL);
+		ivector_destroy(callbacks);
+	}
+
+	register_recurring_callbacks();
+
+	//Advance tick
+	++_tick;
+
+	//TODO: Delay and loop
+}
+
+void runtime_destroy()
+{
+	hashtable_destroy_free(_future_callbacks, NULL, ivector_destroy);
+	ivector_destroy(_recurring_callbacks);
+}