b84f860d86
Complete the A-to-Z Lardon3D maintenance and coherence pass. Generalize host resource policy, remove the global CPU12 ceiling, preserve host CPU/RAM reserves, scale Task capabilities through the Resource Governor, and validate deterministic parallel GV execution. Migrate Project DB to v23 with data-driven camera, lens, optical configuration and calibration profiles, including manual lenses without EXIF. Integrate safe optional LARDON SSD swap/scratch control with Governor and F10 drain/safe-to-unplug semantics. Refactor the ncurses TUI into a runtime observatory with durable progress, elapsed time, smoothed ETA, throughput, resource telemetry, Governor state, optics workflow, colors and compact/no-color fallbacks. Reconcile Queue lifetime, persistence, concurrency, comments, tests, README, AGENTS and canonical documentation. GLOBAL_MAINTENANCE_AUDIT=PASS/FROZEN
509 lines
17 KiB
C
509 lines
17 KiB
C
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "../src/runtime_observer_internal.h"
|
|
|
|
#define GIB (UINT64_C(1024) * UINT64_C(1024) * UINT64_C(1024))
|
|
#define CHECK(condition) \
|
|
do { \
|
|
if (!(condition)) { \
|
|
(void)fprintf(stderr, "runtime observer failure line %d: %s\n",\
|
|
__LINE__, #condition); \
|
|
return false; \
|
|
} \
|
|
} while (0)
|
|
|
|
typedef struct {
|
|
uint64_t now_ns;
|
|
size_t capture_calls;
|
|
bool fail_capture;
|
|
bool destroyed;
|
|
Lardon3DRuntimeObserverSample sample;
|
|
} FakeObserver;
|
|
|
|
static bool
|
|
fake_now(void *context, uint64_t *now_ns)
|
|
{
|
|
FakeObserver *fake = context;
|
|
*now_ns = fake->now_ns;
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
fake_capture(
|
|
void *context,
|
|
Lardon3DRuntimeObserverSample *sample,
|
|
char reason[LARDON3D_TUI_TEXT_CAPACITY]
|
|
)
|
|
{
|
|
FakeObserver *fake = context;
|
|
++fake->capture_calls;
|
|
if (fake->fail_capture) {
|
|
(void)snprintf(reason, LARDON3D_TUI_TEXT_CAPACITY,
|
|
"injected bounded capture failure");
|
|
return false;
|
|
}
|
|
*sample = fake->sample;
|
|
reason[0] = '\0';
|
|
return true;
|
|
}
|
|
|
|
static void
|
|
fake_destroy(void *context)
|
|
{
|
|
((FakeObserver *)context)->destroyed = true;
|
|
}
|
|
|
|
static const Lardon3DRuntimeObserverProviderOps fake_ops = {
|
|
.monotonic_now_ns = fake_now,
|
|
.capture = fake_capture,
|
|
.destroy = fake_destroy,
|
|
};
|
|
|
|
static bool production_stub_enabled;
|
|
static unsigned int last_diagnostic_calls;
|
|
static Lardon3DTaskObservation production_stub_task;
|
|
|
|
/* The production-owner stubs are enabled only for the final association
|
|
* regression. They supply owners, not model results, so the same production
|
|
* observer builder remains under test. */
|
|
size_t
|
|
lardon3d_task_queue_observe(
|
|
Lardon3DTaskQueue *queue,
|
|
Lardon3DTaskObservation *observations,
|
|
size_t capacity,
|
|
Lardon3DTaskQueueSummary *summary
|
|
)
|
|
{
|
|
(void)queue;
|
|
if (summary) {
|
|
*summary = (Lardon3DTaskQueueSummary) {0};
|
|
}
|
|
if (!production_stub_enabled || !observations || capacity == 0) {
|
|
return 0;
|
|
}
|
|
observations[0] = production_stub_task;
|
|
if (summary) {
|
|
summary->running = 1;
|
|
summary->total = 1;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
bool
|
|
lardon3d_resource_observation_capture(
|
|
const Lardon3DHardwareProfile *profile,
|
|
Lardon3DResourceObservation *observation,
|
|
char *error_message,
|
|
size_t error_message_size
|
|
)
|
|
{
|
|
(void)profile;
|
|
if (error_message && error_message_size) {
|
|
error_message[0] = '\0';
|
|
}
|
|
if (!production_stub_enabled || !observation) {
|
|
return false;
|
|
}
|
|
*observation = (Lardon3DResourceObservation) {
|
|
.snapshot = {
|
|
.memory_available_bytes = 8 * GIB,
|
|
.swap_available_bytes = 3 * GIB,
|
|
},
|
|
.swap_total_known = true,
|
|
.swap_total_bytes = 4 * GIB,
|
|
};
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
lardon3d_resource_governor_availability(
|
|
Lardon3DResourceGovernor *governor,
|
|
const Lardon3DResourceSnapshot *snapshot,
|
|
Lardon3DResourceAvailability *availability
|
|
)
|
|
{
|
|
(void)governor;
|
|
(void)snapshot;
|
|
if (!production_stub_enabled || !availability) {
|
|
return false;
|
|
}
|
|
*availability = (Lardon3DResourceAvailability) {
|
|
.memory_budget_bytes = 13 * GIB,
|
|
.cpu_budget = 4,
|
|
.cpu_reserved = 2,
|
|
.cpu_available = 2,
|
|
};
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
lardon3d_resource_governor_get_policy(
|
|
Lardon3DResourceGovernor *governor,
|
|
Lardon3DResourcePolicy *policy
|
|
)
|
|
{
|
|
(void)governor;
|
|
if (!production_stub_enabled || !policy) {
|
|
return false;
|
|
}
|
|
*policy = (Lardon3DResourcePolicy) {
|
|
.system_memory_reserve_bytes = 3 * GIB,
|
|
};
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
lardon3d_resource_governor_get_external_storage(
|
|
Lardon3DResourceGovernor *governor,
|
|
Lardon3DResourceExternalStorage *storage
|
|
)
|
|
{
|
|
(void)governor;
|
|
if (storage) {
|
|
*storage = (Lardon3DResourceExternalStorage) {0};
|
|
}
|
|
if (!production_stub_enabled || !storage) {
|
|
return false;
|
|
}
|
|
*storage = (Lardon3DResourceExternalStorage) {
|
|
.generation = 9,
|
|
.status = LARDON3D_RESOURCE_EXTERNAL_STORAGE_AVAILABLE,
|
|
.new_scratch_allocations_allowed = true,
|
|
};
|
|
(void)snprintf(storage->stable_identity,
|
|
sizeof(storage->stable_identity), "drive-production");
|
|
(void)snprintf(storage->reason, sizeof(storage->reason),
|
|
"registered production snapshot");
|
|
return true;
|
|
}
|
|
|
|
Lardon3DResourcePressure
|
|
lardon3d_resource_governor_pressure(Lardon3DResourceGovernor *governor)
|
|
{
|
|
(void)governor;
|
|
return LARDON3D_RESOURCE_PRESSURE_YELLOW;
|
|
}
|
|
|
|
bool
|
|
lardon3d_resource_governor_internal_cpu_policy(
|
|
Lardon3DResourceGovernor *governor,
|
|
Lardon3DResourceCpuPolicyDiagnostic *diagnostic
|
|
)
|
|
{
|
|
(void)governor;
|
|
if (!production_stub_enabled || !diagnostic) {
|
|
return false;
|
|
}
|
|
*diagnostic = (Lardon3DResourceCpuPolicyDiagnostic) {
|
|
.compute_cpu_count = 4,
|
|
};
|
|
(void)snprintf(diagnostic->reason, sizeof(diagnostic->reason),
|
|
"whole-core compute pool");
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
lardon3d_resource_governor_internal_last_diagnostic(
|
|
Lardon3DResourceGovernor *governor,
|
|
const char *task_kind,
|
|
uint32_t task_kind_version,
|
|
Lardon3DResourceSequenceDiagnostic *diagnostic
|
|
)
|
|
{
|
|
(void)governor;
|
|
(void)task_kind;
|
|
(void)task_kind_version;
|
|
(void)diagnostic;
|
|
++last_diagnostic_calls;
|
|
return false;
|
|
}
|
|
|
|
const char *
|
|
lardon3d_task_state_name(Lardon3DTaskState state)
|
|
{
|
|
static const char *const names[] = {
|
|
"PENDING", "RUNNING", "PAUSED", "CANCELLED", "FAILED", "COMPLETED",
|
|
};
|
|
return state >= TASK_PENDING && state <= TASK_COMPLETED
|
|
? names[state] : "UNKNOWN";
|
|
}
|
|
|
|
static void
|
|
prepare_sample(FakeObserver *fake)
|
|
{
|
|
fake->sample = (Lardon3DRuntimeObserverSample) {
|
|
.realtime_now = {.tv_sec = 100, .tv_nsec = 0},
|
|
.task_count = 1,
|
|
.task_summary = {.running = 1, .total = 1},
|
|
.resource_valid = true,
|
|
.resource_observation = {
|
|
.snapshot = {
|
|
.memory_available_bytes = 8 * GIB,
|
|
.swap_available_bytes = 3 * GIB,
|
|
.memory_pressure_known = true,
|
|
.memory_pressure_avg10 = 0.0,
|
|
.swap_activity_known = true,
|
|
.swap_pages_in = 10,
|
|
.swap_pages_out = 20,
|
|
},
|
|
.swap_total_known = true,
|
|
.swap_total_bytes = 4 * GIB,
|
|
},
|
|
.availability = {
|
|
.memory_budget_bytes = 13 * GIB,
|
|
.memory_reserved_bytes = GIB,
|
|
.cpu_budget = 4,
|
|
.cpu_reserved = 2,
|
|
.cpu_available = 2,
|
|
.gpu_memory_known = true,
|
|
.gpu_memory_reserved_bytes = 128 * UINT64_C(1024) * 1024,
|
|
.gpu_memory_available_bytes = 512 * UINT64_C(1024) * 1024,
|
|
.gpu_slot_budget = 1,
|
|
.gpu_slots_reserved = 1,
|
|
.io_slot_budget = 2,
|
|
.io_slots_reserved = 1,
|
|
.io_slots_available = 1,
|
|
},
|
|
.policy = {.system_memory_reserve_bytes = 3 * GIB},
|
|
.cpu_policy = {.compute_cpu_count = 4},
|
|
.pressure = LARDON3D_RESOURCE_PRESSURE_GREEN,
|
|
.external_storage_registered = true,
|
|
.external_storage = {
|
|
.generation = 7,
|
|
.status = LARDON3D_RESOURCE_EXTERNAL_STORAGE_IN_USE,
|
|
.new_scratch_allocations_allowed = true,
|
|
.scratch_total_known = true,
|
|
.scratch_free_known = true,
|
|
.scratch_total_bytes = 8 * GIB,
|
|
.scratch_free_bytes = 6 * GIB,
|
|
.swap_total_known = true,
|
|
.swap_used_known = true,
|
|
.swap_total_bytes = 4 * GIB,
|
|
.swap_used_bytes = GIB,
|
|
.active_scratch_leases = 2,
|
|
.stable_identity = "drive-1",
|
|
.reason = "registered and in use",
|
|
},
|
|
.ssd_controller_available = true,
|
|
.ssd_snapshot_valid = true,
|
|
.ssd = {
|
|
.state = LARDON3D_SSD_IN_USE,
|
|
.scratch_mounted = true,
|
|
.scratch_lease_count = 2,
|
|
},
|
|
};
|
|
(void)snprintf(fake->sample.cpu_policy.reason,
|
|
sizeof(fake->sample.cpu_policy.reason), "whole-core compute pool");
|
|
fake->sample.tasks[0] = (Lardon3DTaskObservation) {
|
|
.id = 91,
|
|
.has_task_kind = true,
|
|
.task_kind_version = 1,
|
|
.progress = 25,
|
|
.durable_progress_known = true,
|
|
.durable_completed = 25,
|
|
.durable_total = 100,
|
|
.state = TASK_RUNNING,
|
|
.started_at = {.tv_sec = 90, .tv_nsec = 0},
|
|
.has_execution_contract = true,
|
|
.execution_contract = {
|
|
.batch_size = 8,
|
|
.cpu_threads = 2,
|
|
.gpu_slots = 1,
|
|
.io_slots = 1,
|
|
},
|
|
};
|
|
(void)snprintf(fake->sample.tasks[0].name,
|
|
sizeof(fake->sample.tasks[0].name), "matcher");
|
|
(void)snprintf(fake->sample.tasks[0].task_kind,
|
|
sizeof(fake->sample.tasks[0].task_kind), "matcher.run");
|
|
(void)snprintf(fake->sample.tasks[0].message,
|
|
sizeof(fake->sample.tasks[0].message), "matching");
|
|
}
|
|
|
|
static bool
|
|
run_test(void)
|
|
{
|
|
Lardon3DHardwareProfile profile = {
|
|
.logical_cpu_count = 8,
|
|
.memory_total_bytes = 16 * GIB,
|
|
.gpu_available = true,
|
|
.gpu_uses_shared_memory = true,
|
|
};
|
|
FakeObserver fake = {.now_ns = UINT64_C(2000000000)};
|
|
prepare_sample(&fake);
|
|
Lardon3DRuntimeObserver *observer =
|
|
lardon3d_runtime_observer_create_with_provider(
|
|
&profile,
|
|
(Lardon3DRuntimeObserverProvider) {
|
|
.ops = &fake_ops,
|
|
.context = &fake,
|
|
},
|
|
UINT64_C(1000000000));
|
|
CHECK(observer);
|
|
|
|
Lardon3DRuntimeSnapshot view;
|
|
CHECK(lardon3d_runtime_observer_refresh(observer, true, true, &view));
|
|
CHECK(fake.capture_calls == 1);
|
|
CHECK(view.generation == 1);
|
|
CHECK(view.active_task_known && view.active_task_index == 0);
|
|
CHECK(view.stages[LARDON3D_TUI_STAGE_MATCHER].state
|
|
== LARDON3D_TUI_STAGE_RUNNING);
|
|
CHECK(view.stages[LARDON3D_TUI_STAGE_DENSE].state
|
|
== LARDON3D_TUI_STAGE_NOT_APPLICABLE);
|
|
CHECK(view.active_progress.percentage == 25);
|
|
CHECK(view.active_progress.durable_counts_known);
|
|
CHECK(view.active_progress.completed == 25);
|
|
CHECK(view.active_progress.total == 100);
|
|
CHECK(view.active_progress.elapsed_known);
|
|
CHECK(view.active_progress.elapsed_seconds == 10);
|
|
CHECK(view.resources.valid);
|
|
CHECK(view.resources.cpu_logical_total == 8);
|
|
CHECK(view.resources.cpu_active == 2);
|
|
CHECK(view.resources.cpu_admitted_known);
|
|
CHECK(view.resources.cpu_admitted == 2);
|
|
CHECK(view.resources.cpu_available == 2);
|
|
CHECK(view.resources.gpu_slots_active == 1);
|
|
CHECK(!view.resources.gpu_busy_known);
|
|
CHECK(view.resources.ram_reserve_bytes == 3 * GIB);
|
|
CHECK(view.resources.swap_total_bytes == 4 * GIB);
|
|
CHECK(view.resources.swap_used_bytes == GIB);
|
|
CHECK(!view.resources.swap_delta_known);
|
|
CHECK(view.resources.gpu_uses_shared_memory);
|
|
CHECK(view.resources.batch_known);
|
|
CHECK(view.resources.batch_size == 8);
|
|
CHECK(!view.resources.inflight_known);
|
|
CHECK(!view.resources.helpers_known);
|
|
CHECK(view.resources.gpu_backend == LARDON3D_TUI_GPU_BACKEND_UNKNOWN);
|
|
CHECK(view.resources.scratch_known && view.resources.scratch_leases == 2);
|
|
CHECK(view.resources.external_storage_registered);
|
|
CHECK(view.resources.external_storage_status
|
|
== LARDON3D_RESOURCE_EXTERNAL_STORAGE_IN_USE);
|
|
CHECK(view.resources.scratch_new_allocations_allowed);
|
|
CHECK(view.resources.external_swap_used_bytes == GIB);
|
|
CHECK(strcmp(view.resources.external_storage_identity, "drive-1") == 0);
|
|
CHECK(view.ssd.state == LARDON3D_SSD_IN_USE);
|
|
|
|
fake.now_ns += UINT64_C(500000000);
|
|
CHECK(lardon3d_runtime_observer_refresh(observer, true, false, &view));
|
|
CHECK(fake.capture_calls == 1);
|
|
CHECK(view.generation == 1);
|
|
|
|
fake.now_ns += UINT64_C(500000000);
|
|
fake.sample.resource_observation.snapshot.swap_pages_in = 12;
|
|
fake.sample.resource_observation.snapshot.swap_pages_out = 25;
|
|
CHECK(lardon3d_runtime_observer_refresh(observer, true, false, &view));
|
|
CHECK(fake.capture_calls == 2);
|
|
CHECK(view.resources.swap_delta_known);
|
|
CHECK(view.resources.swap_pages_in_delta == 2);
|
|
CHECK(view.resources.swap_pages_out_delta == 5);
|
|
|
|
/* A project identity transition invalidates coalescing immediately. */
|
|
fake.now_ns += 1;
|
|
CHECK(lardon3d_runtime_observer_refresh(observer, false, false, &view));
|
|
CHECK(fake.capture_calls == 3);
|
|
CHECK(view.task_count == 0);
|
|
CHECK(!view.active_task_known);
|
|
CHECK(view.task_summary.total == 0);
|
|
|
|
fake.now_ns += UINT64_C(1000000000);
|
|
fake.fail_capture = true;
|
|
uint64_t generation = view.generation;
|
|
CHECK(!lardon3d_runtime_observer_refresh(observer, false, true, &view));
|
|
CHECK(view.stale);
|
|
CHECK(view.generation == generation);
|
|
CHECK(strstr(view.status, "injected") != NULL);
|
|
|
|
fake.fail_capture = false;
|
|
fake.now_ns += UINT64_C(1000000000);
|
|
fake.sample.resource_observation.snapshot.swap_pages_in = 1;
|
|
fake.sample.resource_observation.snapshot.swap_pages_out = 2;
|
|
CHECK(lardon3d_runtime_observer_refresh(observer, false, true, &view));
|
|
CHECK(!view.resources.swap_delta_known);
|
|
CHECK(!view.stale);
|
|
|
|
/* The admitted Task contract knows batch, but cannot fabricate private
|
|
* inflight/helper dimensions when no Governor diagnostic exists. */
|
|
fake.now_ns += UINT64_C(1000000000);
|
|
CHECK(lardon3d_runtime_observer_refresh(observer, true, true, &view));
|
|
CHECK(view.resources.batch_known && view.resources.batch_size == 8);
|
|
CHECK(!view.resources.inflight_known && !view.resources.helpers_known);
|
|
CHECK(view.resources.gpu_backend
|
|
== LARDON3D_TUI_GPU_BACKEND_UNKNOWN);
|
|
|
|
/* Aggregate CPU reservations cannot fill in the admitted count for a Task
|
|
* whose exact installed contract is absent. */
|
|
fake.sample.tasks[0].has_execution_contract = false;
|
|
fake.sample.tasks[0].execution_contract =
|
|
(Lardon3DTaskExecutionContract) {0};
|
|
fake.now_ns += UINT64_C(1000000000);
|
|
CHECK(lardon3d_runtime_observer_refresh(observer, true, true, &view));
|
|
CHECK(!view.resources.cpu_admitted_known);
|
|
CHECK(view.resources.cpu_admitted == 0);
|
|
CHECK(!view.resources.batch_known);
|
|
fake.sample.tasks[0].has_execution_contract = true;
|
|
fake.sample.tasks[0].execution_contract =
|
|
(Lardon3DTaskExecutionContract) {
|
|
.batch_size = 8,
|
|
.cpu_threads = 2,
|
|
.gpu_slots = 1,
|
|
.io_slots = 1,
|
|
};
|
|
|
|
/* A fully saturated production Queue can expose 64 pending records before
|
|
* the running record in its newest-first order. The 129-entry observation
|
|
* bound and active scan must still select the actual running Task. */
|
|
Lardon3DTaskObservation active = fake.sample.tasks[0];
|
|
fake.sample.task_count = 65;
|
|
fake.sample.task_summary = (Lardon3DTaskQueueSummary) {
|
|
.running = 1,
|
|
.pending = 64,
|
|
.total = 65,
|
|
};
|
|
for (size_t index = 0; index < 64; ++index) {
|
|
fake.sample.tasks[index] = (Lardon3DTaskObservation) {
|
|
.id = UINT64_C(1000) + (uint64_t)index,
|
|
.state = TASK_PENDING,
|
|
};
|
|
(void)snprintf(fake.sample.tasks[index].name,
|
|
sizeof(fake.sample.tasks[index].name), "pending-%zu", index);
|
|
}
|
|
fake.sample.tasks[64] = active;
|
|
fake.now_ns += UINT64_C(1000000000);
|
|
CHECK(lardon3d_runtime_observer_refresh(observer, true, true, &view));
|
|
CHECK(view.task_count == 65);
|
|
CHECK(view.active_task_known && view.active_task_index == 64);
|
|
CHECK(view.tasks[view.active_task_index].id == active.id);
|
|
|
|
lardon3d_runtime_observer_destroy(observer);
|
|
CHECK(fake.destroyed);
|
|
|
|
/* Production capture must not query a kind/version-wide last diagnostic:
|
|
* such a row may belong to a prior Task with the same kind. */
|
|
production_stub_enabled = true;
|
|
production_stub_task = active;
|
|
last_diagnostic_calls = 0;
|
|
int queue_owner;
|
|
int governor_owner;
|
|
observer = lardon3d_runtime_observer_create(&profile,
|
|
(Lardon3DTaskQueue *)&queue_owner,
|
|
(Lardon3DResourceGovernor *)&governor_owner);
|
|
CHECK(observer);
|
|
CHECK(lardon3d_runtime_observer_refresh(observer, true, true, &view));
|
|
CHECK(last_diagnostic_calls == 0);
|
|
CHECK(view.resources.batch_known && view.resources.batch_size == 8);
|
|
CHECK(!view.resources.inflight_known && !view.resources.helpers_known);
|
|
CHECK(view.resources.gpu_backend == LARDON3D_TUI_GPU_BACKEND_UNKNOWN);
|
|
lardon3d_runtime_observer_destroy(observer);
|
|
production_stub_enabled = false;
|
|
return true;
|
|
}
|
|
|
|
int
|
|
main(void)
|
|
{
|
|
return run_test() ? EXIT_SUCCESS : EXIT_FAILURE;
|
|
}
|