Home /Modules/vm/sleela_vm_dynamic_memory_guard.c

sleela_vm_dynamic_memory_guard.c

lib/vm/src/sleela_vm_dynamic_memory_guard.c · 93 line(s) · c

#include "../include/sleela_vm_dynamic_memory_guard.h"

static uint64_t max_u64(uint64_t a, uint64_t b) {
    return a > b ? a : b;
}

int sleela_vm_memory_guard_validate(
    const sleela_vm_memory_guard_config_t *c,
    uint64_t physical_limit) {
    if (!c || !physical_limit) return -1;
    if (!c->initial_limit || !c->hard_limit || !c->maximum_limit) return -2;
    if (c->initial_limit > c->hard_limit) return -3;
    if (c->hard_limit > c->maximum_limit) return -4;
    if (c->maximum_limit > physical_limit) return -5;
    if (c->mode < SLEELA_VM_MEMORY_GUARD_HARD ||
        c->mode > SLEELA_VM_MEMORY_GUARD_AGGRESSIVE) return -6;
    if (c->mode != SLEELA_VM_MEMORY_GUARD_HARD && !c->growth_step) return -7;
    if (c->gc_pressure_percent > 100) return -8;
    if (c->mode == SLEELA_VM_MEMORY_GUARD_HARD && c->allow_growth) return -9;
    return 0;
}

uint64_t sleela_vm_memory_guard_next_limit(
    const sleela_vm_memory_guard_config_t *c,
    const sleela_vm_memory_guard_state_t *s,
    uint64_t required_bytes) {
    uint64_t required;
    uint64_t step;
    uint64_t candidate;

    if (!c || !s || !required_bytes) return 0;
    required = s->current_usage + required_bytes;
    if (required < s->current_usage) return 0;
    if (required <= s->current_limit) return s->current_limit;
    if (c->mode == SLEELA_VM_MEMORY_GUARD_HARD) return 0;
    if (!c->allow_growth || required > c->maximum_limit) return 0;

    step = c->growth_step;
    if (c->mode == SLEELA_VM_MEMORY_GUARD_AGGRESSIVE) {
        candidate = max_u64(required, s->current_limit + step);
    } else {
        candidate = s->current_limit + step;
        if (candidate < s->current_limit) return 0;
        if (candidate < required) {
            uint64_t deficit = required - candidate;
            uint64_t extra_steps = (deficit + step - 1) / step;
            candidate += extra_steps * step;
        }
    }

    if (candidate < required || candidate > c->maximum_limit) return 0;
    return candidate;
}

int sleela_vm_memory_guard_request(
    const sleela_vm_memory_guard_config_t *c,
    sleela_vm_memory_guard_state_t *s,
    uint64_t required_bytes) {
    uint64_t next;

    if (!c || !s || !required_bytes) return SLEELA_VM_MEMORY_INVALID_REQUEST;
    if (s->current_usage + required_bytes < s->current_usage)
        return SLEELA_VM_MEMORY_INVALID_REQUEST;
    if (s->current_usage + required_bytes <= s->current_limit)
        return SLEELA_VM_MEMORY_WITHIN_LIMIT;

    if (c->mode == SLEELA_VM_MEMORY_GUARD_HARD ||
        !c->allow_growth ||
        s->current_usage + required_bytes > c->maximum_limit)
        return SLEELA_VM_MEMORY_LIMIT_REACHED;

    if (c->mode == SLEELA_VM_MEMORY_GUARD_SLOW_CAREFUL &&
        c->growth_delay != 0) {
        s->deferred_requests++;
        return SLEELA_VM_MEMORY_GROW_DEFERRED;
    }

    next = sleela_vm_memory_guard_next_limit(c, s, required_bytes);
    if (!next) return SLEELA_VM_MEMORY_LIMIT_REACHED;

    s->current_limit = next;
    s->growth_events++;
    return SLEELA_VM_MEMORY_GROW_ALLOWED;
}

void sleela_vm_memory_guard_observe(
    sleela_vm_memory_guard_state_t *s,
    uint64_t current_usage) {
    if (!s) return;
    s->current_usage = current_usage;
    if (current_usage > s->peak_usage) s->peak_usage = current_usage;
}