feat(module, stk): dependency ordering, cascade unload, and pending queue

- Refactor the Kahn topological sort into a generic stk_kahn_sort() that
accepts a has_dep callback and an on_cycle callback, eliminating direct
coupling to stk_modules. stk_topo_sort() becomes a thin wrapper using
stk_loaded_has_dep() and stk_log_cycle(). stk_sort_load_order() uses the
same core via stk_batch_has_dep(), which opens tmp files to inspect deps
so simultaneous load events are processed dependency-first without needing
a retry cycle.

- Split stk_module_load() into stk_module_preload(), stk_module_activate(),
stk_module_discard(), and stk_validate_dependencies_single(). preload
handles library loading and metadata only; activate calls init; discard
cleans up without calling shutdown; validate_dependencies_single checks a
single module's deps. stk_module_load() composes these in order and does
not call init if deps are unmet.

- On UNLOAD events in stk_poll(), expand the unload set to include all
transitively dependent loaded modules via stk_collect_dependents(), sort
dependents-first via stk_sort_unload_order(), and unload in that order.
Modules unloaded due to expansion are queued to pending so they reload
automatically when their dependency returns. Remove trim_arrays, now
handled by the compact pass after the unload block.

- On LOAD events with unmet dependencies, add the tmp path to the pending
queue instead of dropping the module. stk_pending_retry() skips already
loaded entries and prunes entries whose file no longer exists. Move the
free_poll label above stk_pending_retry() so retry always runs regardless
of which path exits the event processing block.
This commit is contained in:
anth64 committed 2026-03-07 09:38:46 +01:00
1 parent 55fcc019e4
commit 42a96f2bc0
2 files changed
+614 -182

No files matched your search

+415 -64
View File
@@ -206,12 +206,15 @@ unsigned char stk_validate_dependencies(size_t count)
return result;
}
unsigned char stk_topo_sort(size_t count, size_t *order)
typedef int (*stk_dep_query_fn)(size_t i, size_t j, void *ctx);
static unsigned char stk_kahn_sort(size_t count, size_t *order,
stk_dep_query_fn has_dep, void *ctx,
void (*on_cycle)(size_t i))
{
size_t *in_degree = NULL;
size_t *queue = NULL;
size_t head, tail, sorted, i, d;
int dep_index;
size_t head, tail, sorted, i, j;
unsigned char result = STK_MOD_INIT_SUCCESS;
if (count == 0)
@@ -229,11 +232,9 @@ unsigned char stk_topo_sort(size_t count, size_t *order)
in_degree[i] = 0;
for (i = 0; i < count; i++)
for (d = 0; d < stk_modules[i].dep_count; d++) {
dep_index = is_mod_loaded(stk_modules[i].deps[d].id);
if (dep_index >= 0)
for (j = 0; j < count; j++)
if (i != j && has_dep(i, j, ctx))
in_degree[i]++;
}
head = tail = sorted = 0;
@@ -246,48 +247,59 @@ unsigned char stk_topo_sort(size_t count, size_t *order)
order[sorted++] = mod;
for (i = 0; i < count; i++) {
for (d = 0; d < stk_modules[i].dep_count; d++) {
dep_index =
is_mod_loaded(stk_modules[i].deps[d].id);
if (dep_index != (int)mod)
continue;
if (--in_degree[i] == 0)
queue[tail++] = i;
break;
}
if (i == mod || !has_dep(i, mod, ctx))
continue;
if (--in_degree[i] == 0)
queue[tail++] = i;
}
}
if (sorted != count) {
size_t j;
size_t k;
int in_order;
for (i = 0; i < count; i++) {
in_order = 0;
for (j = 0; j < sorted; j++) {
if (order[j] == i) {
for (k = 0; k < sorted; k++) {
if (order[k] == i) {
in_order = 1;
break;
}
}
if (!in_order)
stk_log(STK_LOG_ERROR,
"Circular dependency detected with %s",
stk_modules[i].id);
if (!in_order && on_cycle)
on_cycle(i);
}
result = STK_MOD_DEP_CIRCULAR_ERROR;
}
done:
if (in_degree)
free(in_degree);
if (queue)
free(queue);
done:
free(in_degree);
free(queue);
return result;
}
unsigned char stk_module_load(const char *path, int index)
static int stk_loaded_has_dep(size_t i, size_t j, void *ctx)
{
size_t d;
(void)ctx;
for (d = 0; d < stk_modules[i].dep_count; d++)
if (is_mod_loaded(stk_modules[i].deps[d].id) == (int)j)
return 1;
return 0;
}
static void stk_log_cycle(size_t i)
{
stk_log(STK_LOG_ERROR, "Circular dependency detected with %s",
stk_modules[i].id);
}
unsigned char stk_topo_sort(size_t count, size_t *order)
{
return stk_kahn_sort(count, order, stk_loaded_has_dep, NULL,
stk_log_cycle);
}
unsigned char stk_module_preload(const char *path, int index)
{
void *handle;
char module_id[STK_MOD_ID_BUFFER];
@@ -323,37 +335,6 @@ unsigned char stk_module_load(const char *path, int index)
extract_module_id(path, module_id);
u.obj = platform_get_symbol(handle, stk_mod_deps_sym);
if (u.obj) {
const stk_dep_t *early_deps = (const stk_dep_t *)u.obj;
size_t early_dep_count = 0;
size_t di;
int found;
while (early_deps[early_dep_count].id[0] != '\0')
early_dep_count++;
for (di = 0; di < early_dep_count; di++) {
found = is_mod_loaded(early_deps[di].id);
if (found < 0) {
platform_unload_library(handle);
return STK_MOD_DEP_NOT_FOUND_ERROR;
}
if (early_deps[di].version[0] &&
!stk_validate_constraint(
early_deps[di].version,
stk_modules[found].version)) {
platform_unload_library(handle);
return STK_MOD_DEP_VERSION_MISMATCH_ERROR;
}
}
}
if (stk_modules[index].init() != STK_MOD_INIT_SUCCESS) {
platform_unload_library(handle);
return STK_MOD_INIT_FAILURE;
}
stk_modules[index].handle = handle;
len = strlen(module_id);
@@ -444,6 +425,70 @@ skip_deps:
return STK_MOD_INIT_SUCCESS;
}
void stk_module_discard(size_t index)
{
platform_unload_library(stk_modules[index].handle);
stk_modules[index].handle = NULL;
stk_modules[index].init = NULL;
stk_modules[index].shutdown = NULL;
stk_modules[index].id[0] = '\0';
stk_modules[index].name[0] = '\0';
stk_modules[index].version[0] = '\0';
stk_modules[index].desc[0] = '\0';
if (stk_modules[index].deps) {
free(stk_modules[index].deps);
stk_modules[index].deps = NULL;
}
stk_modules[index].dep_count = 0;
}
unsigned char stk_module_activate(size_t index)
{
if (stk_modules[index].init() != STK_MOD_INIT_SUCCESS) {
stk_module_discard(index);
return STK_MOD_INIT_FAILURE;
}
return STK_MOD_INIT_SUCCESS;
}
unsigned char stk_validate_dependencies_single(size_t index)
{
size_t d;
int found;
if (stk_modules[index].dep_count == 0)
return STK_MOD_INIT_SUCCESS;
for (d = 0; d < stk_modules[index].dep_count; d++) {
found = is_mod_loaded(stk_modules[index].deps[d].id);
if (found < 0)
return STK_MOD_DEP_NOT_FOUND_ERROR;
if (stk_modules[index].deps[d].version[0] &&
!stk_validate_constraint(stk_modules[index].deps[d].version,
stk_modules[found].version))
return STK_MOD_DEP_VERSION_MISMATCH_ERROR;
}
return STK_MOD_INIT_SUCCESS;
}
unsigned char stk_module_load(const char *path, int index)
{
unsigned char result;
result = stk_module_preload(path, index);
if (result != STK_MOD_INIT_SUCCESS)
return result;
result = stk_validate_dependencies_single(index);
if (result != STK_MOD_INIT_SUCCESS) {
stk_module_discard(index);
return result;
}
return stk_module_activate(index);
}
unsigned char stk_module_load_init(const char *path, int index)
{
int result;
@@ -537,20 +582,227 @@ unsigned char stk_module_realloc_memory(size_t new_capacity)
return 0;
}
typedef struct {
int *file_indices;
char (*file_names)[STK_PATH_MAX];
const char *tmp_dir;
} stk_batch_dep_ctx_t;
static int stk_batch_has_dep(size_t i, size_t j, void *ctx)
{
stk_batch_dep_ctx_t *c = (stk_batch_dep_ctx_t *)ctx;
char id_j[STK_MOD_ID_BUFFER];
char tmp_i[STK_PATH_MAX_OS];
void *h;
const stk_dep_t *deps;
size_t d, dep_count;
union {
void *obj;
} u;
int result = 0;
extract_module_id(c->file_names[c->file_indices[j]], id_j);
tmp_i[0] = '\0';
strncat(tmp_i, c->tmp_dir, STK_PATH_MAX_OS - 1);
strncat(tmp_i, STK_PATH_SEP_STR, STK_PATH_MAX_OS - strlen(tmp_i) - 1);
strncat(tmp_i, c->file_names[c->file_indices[i]],
STK_PATH_MAX_OS - strlen(tmp_i) - 1);
h = platform_load_library(tmp_i);
if (!h)
return 0;
u.obj = platform_get_symbol(h, stk_mod_deps_sym);
if (u.obj) {
deps = (const stk_dep_t *)u.obj;
dep_count = 0;
while (deps[dep_count].id[0] != '\0')
dep_count++;
for (d = 0; d < dep_count; d++) {
if (strncmp(deps[d].id, id_j, STK_MOD_ID_BUFFER) == 0) {
result = 1;
break;
}
}
}
platform_unload_library(h);
return result;
}
void stk_sort_load_order(int *file_indices, size_t n,
char (*file_names)[STK_PATH_MAX], const char *tmp_dir)
{
size_t *order = NULL;
int *result = NULL;
stk_batch_dep_ctx_t ctx;
size_t i;
if (n <= 1)
return;
order = malloc(n * sizeof(size_t));
result = malloc(n * sizeof(int));
if (!order || !result)
goto cleanup;
ctx.file_indices = file_indices;
ctx.file_names = file_names;
ctx.tmp_dir = tmp_dir;
if (stk_kahn_sort(n, order, stk_batch_has_dep, &ctx, NULL) !=
STK_MOD_INIT_SUCCESS)
goto cleanup;
for (i = 0; i < n; i++)
result[i] = file_indices[order[i]];
for (i = 0; i < n; i++)
file_indices[i] = result[i];
cleanup:
free(order);
free(result);
}
void stk_collect_dependents(size_t *indices, size_t *count)
{
size_t i, d;
int in_set, changed;
do {
changed = 0;
for (i = 0; i < module_count; i++) {
in_set = 0;
{
size_t k;
for (k = 0; k < *count; k++) {
if (indices[k] == i) {
in_set = 1;
break;
}
}
}
if (in_set)
continue;
for (d = 0; d < stk_modules[i].dep_count; d++) {
int dep_idx =
is_mod_loaded(stk_modules[i].deps[d].id);
if (dep_idx < 0)
continue;
{
size_t k;
for (k = 0; k < *count; k++) {
if (indices[k] ==
(size_t)dep_idx) {
indices[(*count)++] = i;
changed = 1;
goto next_module;
}
}
}
}
next_module:;
}
} while (changed);
}
void stk_sort_unload_order(size_t *indices, size_t n)
{
size_t *topo = NULL;
size_t *result = NULL;
size_t i, j, k;
int in_set;
if (n <= 1)
return;
topo = malloc(module_count * sizeof(size_t));
result = malloc(n * sizeof(size_t));
if (!topo || !result)
goto fallback;
if (stk_topo_sort(module_count, topo) != STK_MOD_INIT_SUCCESS)
goto fallback;
k = 0;
for (i = module_count; i > 0; --i) {
size_t mod = topo[i - 1];
in_set = 0;
for (j = 0; j < n; j++) {
if (indices[j] == mod) {
in_set = 1;
break;
}
}
if (in_set)
result[k++] = mod;
}
if (k == n) {
for (i = 0; i < n; i++)
indices[i] = result[i];
}
free(topo);
free(result);
return;
fallback:
free(topo);
free(result);
for (i = 0; i < n / 2; i++) {
size_t tmp = indices[i];
indices[i] = indices[n - 1 - i];
indices[n - 1 - i] = tmp;
}
}
void stk_module_unload_all(void)
{
size_t i;
for (i = module_count; i > 0; --i)
stk_module_unload(i - 1);
size_t *order = NULL;
if (module_count == 0)
goto free_mem;
order = malloc(module_count * sizeof(size_t));
if (order) {
for (i = 0; i < module_count; i++)
order[i] = i;
stk_sort_unload_order(order, module_count);
for (i = 0; i < module_count; i++)
stk_module_unload(order[i]);
free(order);
} else {
for (i = module_count; i > 0; --i)
stk_module_unload(i - 1);
}
free_mem:
stk_module_free_memory();
}
void stk_pending_add(const char *path)
{
char (*new_pending)[STK_PATH_MAX_OS];
char incoming_id[STK_MOD_ID_BUFFER];
char existing_id[STK_MOD_ID_BUFFER];
size_t i;
extract_module_id(path, incoming_id);
for (i = 0; i < stk_pending_count; i++) {
extract_module_id(stk_pending[i], existing_id);
if (strncmp(existing_id, incoming_id, STK_MOD_ID_BUFFER) == 0) {
strncpy(stk_pending[i], path, STK_PATH_MAX_OS - 1);
stk_pending[i][STK_PATH_MAX_OS - 1] = '\0';
return;
}
}
new_pending = malloc((stk_pending_count + 1) * sizeof(*stk_pending));
if (!new_pending)
return;
@@ -566,6 +818,74 @@ void stk_pending_add(const char *path)
stk_pending_count++;
}
void stk_pending_add_batch(const char (*paths)[STK_PATH_MAX_OS], size_t count)
{
char (*new_pending)[STK_PATH_MAX_OS];
char incoming_id[STK_MOD_ID_BUFFER];
char existing_id[STK_MOD_ID_BUFFER];
size_t i, j, new_count;
if (!paths || count == 0)
return;
new_count = 0;
for (i = 0; i < count; i++) {
int found = 0;
extract_module_id(paths[i], incoming_id);
for (j = 0; j < stk_pending_count; j++) {
extract_module_id(stk_pending[j], existing_id);
if (strncmp(existing_id, incoming_id,
STK_MOD_ID_BUFFER) == 0) {
strncpy(stk_pending[j], paths[i],
STK_PATH_MAX_OS - 1);
stk_pending[j][STK_PATH_MAX_OS - 1] = '\0';
found = 1;
break;
}
}
if (!found)
new_count++;
}
if (new_count == 0)
return;
new_pending =
malloc((stk_pending_count + new_count) * sizeof(*stk_pending));
if (!new_pending)
return;
for (i = 0; i < stk_pending_count; i++)
memcpy(new_pending[i], stk_pending[i], STK_PATH_MAX_OS);
free(stk_pending);
stk_pending = new_pending;
for (i = 0; i < count; i++) {
int found = 0;
extract_module_id(paths[i], incoming_id);
for (j = 0; j < stk_pending_count; j++) {
extract_module_id(stk_pending[j], existing_id);
if (strncmp(existing_id, incoming_id,
STK_MOD_ID_BUFFER) == 0) {
found = 1;
break;
}
}
if (!found) {
strncpy(stk_pending[stk_pending_count], paths[i],
STK_PATH_MAX_OS - 1);
stk_pending[stk_pending_count][STK_PATH_MAX_OS - 1] =
'\0';
stk_pending_count++;
}
}
}
void stk_pending_remove(const char *id)
{
size_t i, write;
@@ -593,6 +913,7 @@ size_t stk_pending_retry(void)
unsigned char deps_satisfied;
unsigned char result;
void *handle;
void *test;
union {
void *obj;
const char *(*meta_func)(void);
@@ -600,11 +921,41 @@ size_t stk_pending_retry(void)
const stk_dep_t *deps;
size_t dep_count;
int found;
size_t write;
char pending_id[STK_MOD_ID_BUFFER];
if (!stk_pending_count)
return 0;
write = 0;
for (i = 0; i < stk_pending_count; i++) {
test = platform_load_library(stk_pending[i]);
if (test) {
platform_unload_library(test);
if (write != i)
memcpy(stk_pending[write], stk_pending[i],
STK_PATH_MAX_OS);
write++;
}
}
stk_pending_count = write;
if (!stk_pending_count) {
stk_pending_free();
return 0;
}
for (i = 0; i < stk_pending_count; i++) {
extract_module_id(stk_pending[i], pending_id);
if (is_mod_loaded(pending_id) >= 0) {
memcpy(stk_pending[i],
stk_pending[stk_pending_count - 1],
STK_PATH_MAX_OS);
stk_pending_count--;
i--;
continue;
}
handle = platform_load_library(stk_pending[i]);
if (!handle)
continue;