Home /Modules/philosophy/signal_toss.c

signal_toss.c

philosophy/signal_toss.c · 156 line(s) · c

#include "signal_toss.h"
#include <stdlib.h>

struct sl_signal_toss {
    sl_toss_sampler sampler;
    void *ctx;
    sl_consistency_report report;
    uint64_t commits;            /* throttled consistency updates emitted */
    uint64_t last_commit_ms;     /* monotonic time of last commit */
    uint32_t commit_interval_ms; /* derived from commit_per_hour */
    unsigned commit_per_hour;
    sl_thread thread;
    sl_mutex lock;
    bool running;
    bool thread_started;
    bool stop_requested;
};

static unsigned clamp_commit_rate(unsigned per_hour) {
    if (per_hour == 0u)
        return (SL_TOSS_COMMIT_MIN_PER_HOUR + SL_TOSS_COMMIT_MAX_PER_HOUR) / 2u;
    if (per_hour < SL_TOSS_COMMIT_MIN_PER_HOUR) return SL_TOSS_COMMIT_MIN_PER_HOUR;
    if (per_hour > SL_TOSS_COMMIT_MAX_PER_HOUR) return SL_TOSS_COMMIT_MAX_PER_HOUR;
    return per_hour;
}

uint32_t sl_signal_toss_sample_interval_ms(void) {
    return 1000u / SL_TOSS_SAMPLE_HZ; /* ~22 ms => ~44 Hz */
}

uint32_t sl_signal_toss_commit_interval_ms(const sl_signal_toss *toss) {
    if (!toss) return 0u;
    return toss->commit_interval_ms;
}

sl_signal_toss *sl_signal_toss_create(
    sl_toss_sampler sampler, void *ctx, unsigned commit_per_hour) {
    sl_signal_toss *toss;
    if (!sampler) return NULL;
    toss = (sl_signal_toss *)calloc(1u, sizeof(*toss));
    if (!toss) return NULL;
    toss->sampler = sampler;
    toss->ctx = ctx;
    toss->commit_per_hour = clamp_commit_rate(commit_per_hour);
    /* 3600000 ms per hour / commits per hour. */
    toss->commit_interval_ms = (uint32_t)(3600000u / toss->commit_per_hour);
    sl_consistency_report_init(&toss->report);
    if (sl_mutex_init(&toss->lock) != 0) { free(toss); return NULL; }
    return toss;
}

bool sl_signal_toss_step(sl_signal_toss *toss, uint64_t now_ms) {
    sl_branch_view view;
    bool keep_going;
    if (!toss) return false;

    /* Zero the view so an incomplete sampler can't leak stack garbage. */
    view.trait_count = 0u;
    view.weight = SL_BRANCH_WEIGHT_MIN;
    view.studies_economy = false;
    view.economy_arity = 0u;
    view.left_branchpoints = 0u;
    view.right_branchpoints = 0u;
    view.refs = NULL;
    view.ref_count = 0u;

    keep_going = toss->sampler(&view, toss->ctx);

    sl_mutex_lock(&toss->lock);
    (void)sl_consistency_consider(&toss->report, &view);
    /* Commit a consistency update only when the throttle interval elapsed and
     * the branch just considered was consistent. */
    if (toss->report.last_code == SL_CONSISTENT) {
        if (toss->last_commit_ms == 0u ||
            now_ms - toss->last_commit_ms >= toss->commit_interval_ms) {
            ++toss->commits;
            toss->last_commit_ms = now_ms;
        }
    }
    sl_mutex_unlock(&toss->lock);
    return keep_going;
}

static int toss_worker(void *arg) {
    sl_signal_toss *toss = (sl_signal_toss *)arg;
    const uint32_t sample_ms = sl_signal_toss_sample_interval_ms();
    for (;;) {
        bool stop;
        sl_mutex_lock(&toss->lock);
        stop = toss->stop_requested;
        sl_mutex_unlock(&toss->lock);
        if (stop) break;

        if (!sl_signal_toss_step(toss, sl_monotonic_ms())) break;
        sl_sleep_ms(sample_ms);
    }
    sl_mutex_lock(&toss->lock);
    toss->running = false;
    sl_mutex_unlock(&toss->lock);
    return 0;
}

int sl_signal_toss_start(sl_signal_toss *toss) {
    if (!toss) return 1;
    sl_mutex_lock(&toss->lock);
    if (toss->running) { sl_mutex_unlock(&toss->lock); return 0; }
    toss->stop_requested = false;
    toss->running = true;
    sl_mutex_unlock(&toss->lock);

    if (sl_thread_start(&toss->thread, toss_worker, toss) != 0) {
        sl_mutex_lock(&toss->lock);
        toss->running = false;
        sl_mutex_unlock(&toss->lock);
        return 1;
    }
    toss->thread_started = true;
    return 0;
}

void sl_signal_toss_stop(sl_signal_toss *toss) {
    if (!toss) return;
    sl_mutex_lock(&toss->lock);
    toss->stop_requested = true;
    sl_mutex_unlock(&toss->lock);
    if (toss->thread_started) {
        (void)sl_thread_join(&toss->thread);
        toss->thread_started = false;
    }
}

void sl_signal_toss_destroy(sl_signal_toss *toss) {
    if (!toss) return;
    sl_signal_toss_stop(toss);
    sl_mutex_destroy(&toss->lock);
    free(toss);
}

sl_consistency_report sl_signal_toss_snapshot(sl_signal_toss *toss) {
    sl_consistency_report snap;
    if (!toss) { sl_consistency_report_init(&snap); return snap; }
    sl_mutex_lock(&toss->lock);
    snap = toss->report;
    sl_mutex_unlock(&toss->lock);
    return snap;
}

uint64_t sl_signal_toss_commits(sl_signal_toss *toss) {
    uint64_t c;
    if (!toss) return 0u;
    sl_mutex_lock(&toss->lock);
    c = toss->commits;
    sl_mutex_unlock(&toss->lock);
    return c;
}