Home /Modules/os-level-support/osls_runtime.c

osls_runtime.c

os-level-support/runtime/osls_runtime.c · 140 line(s) · c

#include "osls_runtime.h"

#include <stdlib.h>
#include <string.h>

typedef struct hook_slot {
    osls_runtime_token token;
    osls_event_kind kind;
    osls_event_callback callback;
    void *user_data;
    int active;
} hook_slot;

typedef struct task_slot {
    osls_task_callback callback;
    void *user_data;
} task_slot;

struct osls_runtime {
    hook_slot hooks[OSLS_RUNTIME_MAX_HOOKS];
    task_slot tasks[OSLS_RUNTIME_MAX_TASKS];
    size_t task_head;
    size_t task_count;
    uint64_t next_token;
    uint64_t event_sequence;
    unsigned dispatch_depth;
    int running_task;
};

osls_runtime_status osls_runtime_create(osls_runtime **out_runtime) {
    osls_runtime *runtime;
    if (!out_runtime) return OSLS_RUNTIME_INVALID_ARGUMENT;
    *out_runtime = NULL;
    runtime = (osls_runtime *)calloc(1, sizeof(*runtime));
    if (!runtime) return OSLS_RUNTIME_OUT_OF_MEMORY;
    runtime->next_token = 1;
    *out_runtime = runtime;
    return OSLS_RUNTIME_OK;
}

void osls_runtime_destroy(osls_runtime *runtime) {
    if (!runtime) return;
    /* Destroying while a callback is active is a caller contract violation. */
    memset(runtime, 0, sizeof(*runtime));
    free(runtime);
}

osls_runtime_status osls_runtime_subscribe(osls_runtime *runtime,
    osls_event_kind kind, osls_event_callback callback, void *user_data,
    osls_runtime_token *out_token) {
    size_t i;
    if (!runtime || !callback || !out_token || kind < OSLS_EVENT_USER || kind > OSLS_EVENT_IO_READY)
        return OSLS_RUNTIME_INVALID_ARGUMENT;
    if (runtime->dispatch_depth) return OSLS_RUNTIME_BUSY;
    for (i = 0; i < OSLS_RUNTIME_MAX_HOOKS; ++i) {
        if (!runtime->hooks[i].active) {
            osls_runtime_token token = runtime->next_token++;
            if (token == 0) token = runtime->next_token++;
            runtime->hooks[i].token = token;
            runtime->hooks[i].kind = kind;
            runtime->hooks[i].callback = callback;
            runtime->hooks[i].user_data = user_data;
            runtime->hooks[i].active = 1;
            *out_token = token;
            return OSLS_RUNTIME_OK;
        }
    }
    return OSLS_RUNTIME_CAPACITY;
}

osls_runtime_status osls_runtime_unsubscribe(osls_runtime *runtime, osls_runtime_token token) {
    size_t i;
    if (!runtime || token == 0) return OSLS_RUNTIME_INVALID_ARGUMENT;
    if (runtime->dispatch_depth) return OSLS_RUNTIME_BUSY;
    for (i = 0; i < OSLS_RUNTIME_MAX_HOOKS; ++i) {
        if (runtime->hooks[i].active && runtime->hooks[i].token == token) {
            memset(&runtime->hooks[i], 0, sizeof(runtime->hooks[i]));
            return OSLS_RUNTIME_OK;
        }
    }
    return OSLS_RUNTIME_NOT_FOUND;
}

osls_runtime_status osls_runtime_emit(osls_runtime *runtime, osls_event_kind kind,
    const void *payload, size_t payload_size) {
    osls_event event;
    size_t i;
    osls_runtime_status result = OSLS_RUNTIME_OK;
    if (!runtime || kind < OSLS_EVENT_USER || kind > OSLS_EVENT_IO_READY ||
        (!payload && payload_size != 0)) return OSLS_RUNTIME_INVALID_ARGUMENT;
    event.kind = kind;
    event.sequence = ++runtime->event_sequence;
    event.payload = payload;
    event.payload_size = payload_size;
    ++runtime->dispatch_depth;
    for (i = 0; i < OSLS_RUNTIME_MAX_HOOKS; ++i) {
        hook_slot *slot = &runtime->hooks[i];
        if (slot->active && slot->kind == kind) {
            result = slot->callback(runtime, &event, slot->user_data);
            if (result != OSLS_RUNTIME_OK) break;
        }
    }
    --runtime->dispatch_depth;
    return result;
}

osls_runtime_status osls_runtime_post(osls_runtime *runtime,
    osls_task_callback callback, void *user_data) {
    size_t tail;
    if (!runtime || !callback) return OSLS_RUNTIME_INVALID_ARGUMENT;
    if (runtime->task_count == OSLS_RUNTIME_MAX_TASKS) return OSLS_RUNTIME_CAPACITY;
    tail = (runtime->task_head + runtime->task_count) % OSLS_RUNTIME_MAX_TASKS;
    runtime->tasks[tail].callback = callback;
    runtime->tasks[tail].user_data = user_data;
    ++runtime->task_count;
    return OSLS_RUNTIME_OK;
}

osls_runtime_status osls_runtime_run_one(osls_runtime *runtime, int *out_ran) {
    task_slot task;
    osls_runtime_status result;
    if (!runtime || !out_ran) return OSLS_RUNTIME_INVALID_ARGUMENT;
    *out_ran = 0;
    if (runtime->running_task) return OSLS_RUNTIME_BUSY;
    if (!runtime->task_count) return OSLS_RUNTIME_OK;
    task = runtime->tasks[runtime->task_head];
    memset(&runtime->tasks[runtime->task_head], 0, sizeof(runtime->tasks[0]));
    runtime->task_head = (runtime->task_head + 1) % OSLS_RUNTIME_MAX_TASKS;
    --runtime->task_count;
    runtime->running_task = 1;
    *out_ran = 1;
    result = task.callback(runtime, task.user_data);
    runtime->running_task = 0;
    return result;
}

size_t osls_runtime_pending(const osls_runtime *runtime) {
    return runtime ? runtime->task_count : 0;
}