fy59/lardon3d
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
lardon3d/tests/test_matcher_task.c
fy59 b84f860d86 refactor(core): freeze global maintenance baseline 
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
2026-09-01 08:00:47 +02:00

2664 lines
124 KiB
C
Raw Blame History

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <sched.h>
#include <sqlite3.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#ifdef __linux__
#include <sys/types.h>
#endif
#include <unistd.h>
#include <lardon3d/feature_extractor.h>
#include <lardon3d/feature_store.h>
#include <lardon3d/hardware_profile.h>
#include <lardon3d/matcher_task.h>
#include <lardon3d/project.h>
#include <lardon3d/task_checkpoint.h>
#include <lardon3d/task_queue.h>
#include "../src/matcher_task_benchmark_internal.h"
#include "../src/orb_vulkan_backend_internal.h"
#include "../src/resource_governor_internal.h"
#define CHECK(condition) \
do { \
if (!(condition)) { \
(void)fprintf(stderr, "Échec ligne %d : %s\n", __LINE__, #condition); \
return false; \
} \
} while (0)
enum {
IMAGE_COUNT = 42,
PAIR_COUNT = IMAGE_COUNT - 1,
PERSISTED_PAIR_COUNT = PAIR_COUNT - 1,
/* The fixture makes twelve adjacent pairs eligible, then deliberately
* deletes eligible pair index two to preserve sparse Candidate Pair IDs. */
PIPELINE_ELIGIBLE_PAIR_COUNT = 11,
};
void lardon3d_matcher_task_test_reset_backend_counters(void);
size_t lardon3d_matcher_task_test_vulkan_uses(void);
size_t lardon3d_matcher_task_test_forced_fallbacks(void);
size_t lardon3d_matcher_task_test_overlap_publications(void);
uint64_t lardon3d_matcher_task_test_max_retained_vulkan_payload(void);
size_t lardon3d_matcher_task_test_event_count(void);
bool lardon3d_matcher_task_test_event(size_t index, int *kind,
uint64_t *candidate_pair_id,
size_t *order);
bool lardon3d_matcher_task_test_auto_capability_envelope(
size_t benchmark_inflight_override, size_t benchmark_batch_override,
Lardon3DTaskCapabilityEnvelope *envelope);
enum {
TEST_EVENT_GPU_SUBMIT = 1,
TEST_EVENT_GPU_FINISH = 2,
TEST_EVENT_PUBLICATION_START = 3,
TEST_EVENT_PUBLICATION_FINISH = 4,
};
typedef struct {
char root[PATH_MAX];
Lardon3DAppState state;
Lardon3DProjectDbScanSet scanset;
Lardon3DProjectDbImage images[IMAGE_COUNT];
Lardon3DProjectDbCandidatePair pairs[PAIR_COUNT];
unsigned char feature_fingerprint[32];
} Fixture;
static Lardon3DResourcePolicy interactive_policy(void) {
return (Lardon3DResourcePolicy){
.system_memory_reserve_bytes = 4ULL * 1024 * 1024 * 1024,
.emergency_memory_floor_bytes = 2ULL * 1024 * 1024 * 1024,
.system_cpu_reserve = 4,
.maximum_cpu_load_ratio = 1.0,
.maximum_cpu_pressure_avg10 = 100.0,
.maximum_memory_pressure_avg10 = 100.0,
.maximum_io_pressure_avg10 = 100.0,
.io_slot_capacity = 1,
.gpu_slot_capacity = 1,
};
}
#ifdef LARDON3D_MATCHER_TASK_VULKAN
static bool matcher_capability_boundary_case(
const Lardon3DTaskCapabilityEnvelope *envelope, uint64_t total_bytes,
uint64_t available_bytes, Lardon3DResourceDecisionKind expected_decision,
Lardon3DResourceBackend expected_backend, size_t expected_batch,
uint64_t expected_memory_bytes, uint64_t expected_gpu_memory_bytes) {
const uint64_t gib = UINT64_C(1024) * 1024 * 1024;
Lardon3DHardwareProfile profile = {
.logical_cpu_count = 16,
.page_size_bytes = 4096,
.memory_total_bytes = total_bytes,
.gpu_available = true,
.gpu_uses_shared_memory = true,
.cpu_architecture = "boundary-test",
};
Lardon3DResourcePolicy policy = {
.system_memory_reserve_bytes = 3 * gib,
.emergency_memory_floor_bytes = 2 * gib,
.system_cpu_reserve = 0,
.maximum_cpu_load_ratio = 1.0,
.maximum_cpu_pressure_avg10 = 100.0,
.maximum_memory_pressure_avg10 = 100.0,
.maximum_io_pressure_avg10 = 100.0,
.gpu_slot_capacity = 1,
.io_slot_capacity = 1,
};
Lardon3DResourceGovernor *governor =
lardon3d_resource_governor_create(&profile, &policy);
if (!governor ||
!lardon3d_resource_governor_internal_set_backend_available(
governor, LARDON3D_RESOURCE_BACKEND_ORB_VULKAN, true)) {
lardon3d_resource_governor_destroy(governor);
return false;
}
Lardon3DResourceSnapshot snapshot = {
.memory_available_bytes = available_bytes,
.swap_activity_known = true,
};
if (clock_gettime(CLOCK_MONOTONIC, &snapshot.captured_at) != 0) {
lardon3d_resource_governor_destroy(governor);
return false;
}
Lardon3DResourceCapabilitySelection selection = {0};
Lardon3DResourceReservation *reservation = NULL;
bool success = lardon3d_resource_governor_internal_reserve_capability(
governor, &snapshot, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, envelope, &selection, &reservation);
bool admitting = expected_decision == LARDON3D_RESOURCE_START ||
expected_decision == LARDON3D_RESOURCE_REDUCE_BATCH;
success = success && selection.decision.kind == expected_decision &&
((admitting && reservation != NULL &&
selection.capability.backend == expected_backend &&
selection.decision.batch_size == expected_batch) ||
(!admitting && reservation == NULL));
if (!success) {
fprintf(stderr,
"boundary actual decision=%d backend=%d batch=%zu reservation=%s; "
"expected decision=%d backend=%d batch=%zu\n",
(int)selection.decision.kind, (int)selection.capability.backend,
selection.decision.batch_size, reservation ? "yes" : "no",
(int)expected_decision, (int)expected_backend, expected_batch);
}
if (success && reservation) {
Lardon3DResourceReservationInfo information;
success = lardon3d_resource_reservation_get_active(
governor, reservation, &information) &&
information.memory_bytes == expected_memory_bytes &&
information.gpu_memory_bytes == expected_gpu_memory_bytes &&
lardon3d_resource_governor_release(governor, reservation);
reservation = NULL;
}
if (reservation) {
(void)lardon3d_resource_governor_release(governor, reservation);
}
lardon3d_resource_governor_destroy(governor);
return success;
}
#endif
static bool matcher_exact_memory_boundary_test(void) {
#ifdef LARDON3D_MATCHER_TASK_VULKAN
const uint64_t gib = UINT64_C(1024) * 1024 * 1024;
const uint64_t per_pair = UINT64_C(10) * 1024 * 1024;
const uint64_t per_slot = UINT64_C(640) * 1024;
const uint64_t normal_window = 8 * per_pair + per_slot;
const uint64_t normal_total = 3 * gib + normal_window;
const uint64_t normal_gpu_minimum = 3 * gib + per_pair + per_slot;
const uint64_t normal_cpu_minimum = 3 * gib + per_pair;
Lardon3DTaskCapabilityEnvelope normal;
CHECK(lardon3d_matcher_task_test_auto_capability_envelope(0, 0, &normal));
CHECK(normal.count == 2 &&
normal.capabilities[0].backend ==
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN &&
normal.capabilities[0].estimate.maximum_batch_size == 8 &&
normal.capabilities[0].sustained_gpu_batch_feedback &&
normal.capabilities[0].inflight_limit == 1 &&
normal.capabilities[0].minimum_inflight_limit == 1 &&
normal.capabilities[0].gpu_memory_bytes_per_inflight == per_slot &&
normal_total < 3 * gib + 12 * per_pair + 2 * per_slot);
/* The exact maximum proves that the old depth-two/batch-twelve prefilter is
* gone. Falling below that maximum must not reject an adaptive capability:
* AUTO can still admit the immutable batch-one contract. Only the exact
* minimum boundaries select CPU fallback and finally reject both arms. */
CHECK(matcher_capability_boundary_case(
&normal, normal_total, normal_total, LARDON3D_RESOURCE_START,
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN, 1, per_pair, per_slot));
CHECK(matcher_capability_boundary_case(
&normal, normal_total - 1, normal_total - 1,
LARDON3D_RESOURCE_START, LARDON3D_RESOURCE_BACKEND_ORB_VULKAN, 1,
per_pair, per_slot));
CHECK(matcher_capability_boundary_case(
&normal, normal_gpu_minimum - 1, normal_gpu_minimum - 1,
LARDON3D_RESOURCE_START, LARDON3D_RESOURCE_BACKEND_CPU, 1, per_pair, 0));
CHECK(matcher_capability_boundary_case(
&normal, normal_cpu_minimum - 1, normal_cpu_minimum - 1,
LARDON3D_RESOURCE_REJECT, LARDON3D_RESOURCE_BACKEND_FIXED, 0, 0, 0));
#if defined(LARDON3D_MATCHER_TASK_BENCHMARK_PIPELINE)
const uint64_t forced_window = 2 * per_pair + per_slot;
const uint64_t forced_total = 3 * gib + forced_window;
Lardon3DTaskCapabilityEnvelope forced;
CHECK(lardon3d_matcher_task_test_auto_capability_envelope(1, 2, &forced));
CHECK(forced.count == 1 &&
forced.capabilities[0].backend ==
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN &&
forced.capabilities[0].estimate.minimum_batch_size == 2 &&
forced.capabilities[0].estimate.maximum_batch_size == 2 &&
!forced.capabilities[0].sustained_gpu_batch_feedback &&
forced.capabilities[0].inflight_limit == 1 &&
forced.capabilities[0].minimum_inflight_limit == 1 &&
forced_total < 3 * gib + 12 * per_pair + 2 * per_slot);
CHECK(matcher_capability_boundary_case(
&forced, forced_total, forced_total, LARDON3D_RESOURCE_START,
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN, 2, 2 * per_pair, per_slot));
CHECK(matcher_capability_boundary_case(
&forced, forced_total - 1, forced_total - 1,
LARDON3D_RESOURCE_REJECT, LARDON3D_RESOURCE_BACKEND_FIXED, 0, 0, 0));
/* Exact sizing never weakens the 3 GiB host reserve: an otherwise valid
* forced capability waits and owns no reservation at that current snapshot. */
CHECK(matcher_capability_boundary_case(
&forced, forced_total, 2 * gib, LARDON3D_RESOURCE_WAIT,
LARDON3D_RESOURCE_BACKEND_FIXED, 0, 0, 0));
Lardon3DTaskCapabilityEnvelope forced_twelve;
CHECK(lardon3d_matcher_task_test_auto_capability_envelope(
1, 12, &forced_twelve) &&
forced_twelve.count == 1 &&
forced_twelve.capabilities[0].estimate.minimum_batch_size == 12 &&
forced_twelve.capabilities[0].estimate.maximum_batch_size == 12 &&
!forced_twelve.capabilities[0].batch_adaptive &&
!forced_twelve.capabilities[0].sustained_gpu_batch_feedback);
#endif
#endif
return true;
}
static bool join_path(char output[PATH_MAX], const char *left,
const char *right) {
int written = snprintf(output, PATH_MAX, "%s/%s", left, right);
return written > 0 && (size_t)written < PATH_MAX;
}
static bool query_integer(const char *path, const char *sql,
sqlite3_int64 expected) {
sqlite3 *connection = NULL;
sqlite3_stmt *statement = NULL;
bool success =
sqlite3_open_v2(path, &connection, SQLITE_OPEN_READONLY, NULL) ==
SQLITE_OK &&
sqlite3_prepare_v2(connection, sql, -1, &statement, NULL) == SQLITE_OK &&
sqlite3_step(statement) == SQLITE_ROW &&
sqlite3_column_int64(statement, 0) == expected;
if (statement) {
(void)sqlite3_finalize(statement);
}
if (connection) {
(void)sqlite3_close(connection);
}
return success;
}
static bool candidate_results_have_one_evidence(const char *path,
uint64_t candidate_pair_id) {
char sql[512];
int written = snprintf(
sql, sizeof(sql),
"SELECT count(*) FROM (SELECT candidate_pair_id FROM match_results "
"WHERE candidate_pair_id=%lu GROUP BY candidate_pair_id HAVING "
"count(DISTINCT result_status||':'||match_count||':'||"
"ifnull(hex(match_asset_sha256),''))<>1)",
(unsigned long)candidate_pair_id);
return written > 0 && (size_t)written < sizeof(sql) &&
query_integer(path, sql, 0);
}
#ifdef LARDON3D_MATCHER_TASK_VULKAN
static bool wait_candidate_results_have_one_evidence(
const char *path, uint64_t candidate_pair_id) {
/* Queue state may become terminal immediately before its finished callback
* releases the DB transaction. Retry the observable read boundary without
* timing sleeps; a real duplicate never converges to one scientific value. */
for (size_t attempt = 0; attempt < 2000000; ++attempt) {
if (candidate_results_have_one_evidence(path, candidate_pair_id)) {
return true;
}
sched_yield();
}
return false;
}
static bool find_test_event(int wanted_kind, uint64_t wanted_pair,
size_t *order) {
if (!order) return false;
size_t count = lardon3d_matcher_task_test_event_count();
for (size_t index = 0; index < count; ++index) {
int kind = 0;
uint64_t pair = 0;
size_t candidate_order = 0;
if (lardon3d_matcher_task_test_event(index, &kind, &pair,
&candidate_order) &&
kind == wanted_kind && pair == wanted_pair) {
*order = candidate_order;
return true;
}
}
return false;
}
static bool staged_match_temporaries_absent_once(const Fixture *fixture) {
char assets[PATH_MAX];
char matches[PATH_MAX];
if (!join_path(assets, fixture->state.project_path, "assets") ||
!join_path(matches, assets, "matches")) {
return false;
}
DIR *directory = opendir(matches);
if (!directory) return false;
bool clean = true;
for (struct dirent *entry = readdir(directory); entry;
entry = readdir(directory)) {
if (strncmp(entry->d_name, ".match-", 7) == 0) {
clean = false;
break;
}
}
return closedir(directory) == 0 && clean;
}
static bool no_staged_match_temporaries(const Fixture *fixture) {
/* Task state may become FAILED before the callback unwinds its private stage
* cleanup. Poll the observable filesystem boundary without sleeps; Queue's
* single owner must converge before another Task can consume the slot. */
for (size_t attempt = 0; attempt < 2000000; ++attempt) {
if (staged_match_temporaries_absent_once(fixture)) return true;
sched_yield();
}
return false;
}
#endif
static bool downgrade_project_to_historical_v10(const char *database_path) {
sqlite3 *connection = NULL;
if (sqlite3_open_v2(database_path, &connection, SQLITE_OPEN_READWRITE,
NULL) != SQLITE_OK) {
if (connection) {
(void)sqlite3_close(connection);
}
return false;
}
static const char sql[] =
"PRAGMA foreign_keys=OFF;BEGIN IMMEDIATE;"
"DROP TABLE IF EXISTS capture_calibration_selections;"
"DROP TABLE IF EXISTS optical_calibration_profiles;"
"DROP TABLE IF EXISTS capture_optical_configurations;"
"DROP INDEX IF EXISTS acquisition_campaign_capture_identity_v23;"
"DROP TABLE IF EXISTS acquisition_campaign_group_optics;"
"DROP TABLE IF EXISTS optical_configurations;"
"DROP TABLE IF EXISTS lens_profile_aliases;DROP TABLE IF EXISTS lens_profiles;"
"DROP TABLE IF EXISTS camera_body_aliases;DROP TABLE IF EXISTS camera_body_profiles;"
"DROP TABLE IF EXISTS asset_derivations;"
"DROP TABLE IF EXISTS capture_selections;"
"DROP TABLE IF EXISTS capture_assets;"
"DROP TABLE IF EXISTS capture_images;"
"DROP TABLE IF EXISTS captures;"
"DROP TABLE IF EXISTS incremental_reconstruction_tasks;"
"DROP TABLE IF EXISTS incremental_reconstructions;"
"DROP TABLE IF EXISTS sparse_sfm_tasks;"
"DROP TABLE IF EXISTS sparse_landmark_observations;"
"DROP TABLE IF EXISTS sparse_landmarks;"
"DROP TABLE IF EXISTS sparse_registered_images;"
"DROP TABLE IF EXISTS sparse_reconstruction_components;"
"DROP TABLE IF EXISTS sparse_reconstructions;"
"DROP TABLE IF EXISTS sparse_calibration_scope_images;"
"DROP TABLE IF EXISTS sparse_calibration_scopes;"
"DROP TABLE IF EXISTS sparse_calibrations;"
"DROP TABLE geometric_verifier_tasks;"
"DROP TABLE geometric_verification_results;"
"DROP TABLE matcher_tasks;"
"DROP TABLE track_observations;"
"DROP TABLE tracks;"
"DROP TABLE track_sets;DROP TABLE track_builder_tasks;"
"UPDATE metadata SET value=10 WHERE key='schema_version';"
"COMMIT;PRAGMA foreign_keys=ON;";
bool success = sqlite3_exec(connection, sql, NULL, NULL, NULL) == SQLITE_OK;
return sqlite3_close(connection) == SQLITE_OK && success;
}
static bool remove_tree(const char *path) {
struct stat information;
if (lstat(path, &information) != 0) {
return errno == ENOENT;
}
if (!S_ISDIR(information.st_mode)) {
return unlink(path) == 0;
}
DIR *directory = opendir(path);
if (!directory) {
return false;
}
bool success = true;
for (struct dirent *entry = readdir(directory); entry;
entry = readdir(directory)) {
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
continue;
}
char child[PATH_MAX];
if (!join_path(child, path, entry->d_name) || !remove_tree(child)) {
success = false;
}
}
if (closedir(directory) != 0 || rmdir(path) != 0) {
success = false;
}
return success;
}
static bool create_runtime(Lardon3DAppState *state) {
state->hardware_profile = (Lardon3DHardwareProfile){
.logical_cpu_count = 16,
.page_size_bytes = 4096,
.memory_total_bytes = 16ULL * 1024 * 1024 * 1024,
.gpu_available = true,
.gpu_uses_shared_memory = true,
.cpu_architecture = "test",
};
Lardon3DResourcePolicy policy = interactive_policy();
state->resource_governor =
lardon3d_resource_governor_create(&state->hardware_profile, &policy);
state->orb_vulkan_backend = lardon3d_orb_vulkan_backend_create();
state->task_queue =
state->resource_governor && state->orb_vulkan_backend
? lardon3d_task_queue_create(state->resource_governor, 16)
: NULL;
return state->task_queue != NULL;
}
static bool wait_state(Lardon3DTaskQueue *queue, uint64_t task_id,
Lardon3DTaskState wanted,
Lardon3DTaskSnapshot *snapshot) {
struct timespec deadline;
if (clock_gettime(CLOCK_MONOTONIC, &deadline) != 0) return false;
/* ASan/UBSan intentionally makes the real Vulkan fixture much slower. A
* wall-clock bound tests eventual Queue state without turning main-thread
* polling speed into an accidental timeout contract. */
deadline.tv_sec += 30;
for (;;) {
if (lardon3d_task_queue_get(queue, task_id, snapshot) &&
snapshot->state == wanted) {
return true;
}
struct timespec now;
if (clock_gettime(CLOCK_MONOTONIC, &now) != 0 ||
now.tv_sec > deadline.tv_sec ||
(now.tv_sec == deadline.tv_sec && now.tv_nsec >= deadline.tv_nsec)) {
return false;
}
sched_yield();
}
}
static bool wait_durable_state(Lardon3DProjectDb *database, uint64_t task_id,
Lardon3DTaskState wanted,
Lardon3DProjectDbTask *durable_task) {
struct timespec deadline;
if (clock_gettime(CLOCK_MONOTONIC, &deadline) != 0) return false;
deadline.tv_sec += 30;
for (;;) {
if (lardon3d_project_db_load_task(database, task_id, durable_task) ==
LARDON3D_PROJECT_DB_OK &&
durable_task->saved_state == wanted) {
return true;
}
struct timespec now;
if (clock_gettime(CLOCK_MONOTONIC, &now) != 0 ||
now.tv_sec > deadline.tv_sec ||
(now.tv_sec == deadline.tv_sec && now.tv_nsec >= deadline.tv_nsec)) {
return false;
}
sched_yield();
}
}
static void image_asset_path(const unsigned char hash[32], char path[4096]) {
static const char digits[] = "0123456789abcdef";
char hex[65];
for (size_t index = 0; index < 32; ++index) {
hex[2 * index] = digits[hash[index] >> 4];
hex[2 * index + 1] = digits[hash[index] & 15U];
}
hex[64] = '\0';
(void)snprintf(path, 4096, "assets/images/%c%c/%s", hex[0], hex[1], hex);
}
static bool register_image(Fixture *fixture, unsigned char seed, size_t index) {
unsigned char hash[32];
memset(hash, seed, sizeof(hash));
char path[4096];
image_asset_path(hash, path);
Lardon3DProjectDbImageRegisterStatus status;
return lardon3d_project_db_register_image(
fixture->state.project_db, fixture->scanset.scanset_id, hash, path,
1, "fixture.bin", "/synthetic/fixture.bin", 0, seed, &status,
&fixture->images[index]) == LARDON3D_PROJECT_DB_OK;
}
static bool publish_features(Fixture *fixture, size_t image_index) {
const char *pipeline_fixture = getenv("LARDON3D_TEST_MATCHER_PIPELINE_FIXTURE");
const size_t eligible_image_count =
pipeline_fixture && strcmp(pipeline_fixture, "1") == 0 ? 13U : 3U;
uint32_t feature_count = image_index < eligible_image_count ? 769U : 1U;
Lardon3DFeatureKeypoint *keypoints =
calloc(feature_count, sizeof(*keypoints));
unsigned char *descriptors = calloc(feature_count, 32);
if (!keypoints || !descriptors) {
free(keypoints);
free(descriptors);
return false;
}
for (uint32_t index = 0; index < feature_count; ++index) {
keypoints[index].size = 1.0F;
/* The first two pairs have more than 768 descriptors per side, forcing
* consecutive audited Vulkan submissions while retaining bounded fixture
* memory and deterministic CPU/file parity. */
uint32_t value = image_index < eligible_image_count
? index : (uint32_t)image_index;
for (size_t byte = 0; byte < 32; ++byte) {
descriptors[(size_t)index * 32 + byte] =
(unsigned char)((value >> (8U * (byte % 4))) ^ (uint32_t)(byte * 29));
}
}
Lardon3DExtractedFeatures features = {
.image_width = 64,
.image_height = 64,
.feature_count = feature_count,
.keypoints = keypoints,
.descriptors = descriptors,
.descriptor_bytes = (size_t)feature_count * 32,
};
Lardon3DProjectDbFeatureSet feature_set;
bool success = lardon3d_feature_store_publish_v2(
&fixture->state, fixture->images[image_index].image_id, 0, "orb",
1, fixture->feature_fingerprint, LARDON3D_FEATURE_DESCRIPTOR_U8,
32, 0, &features, &feature_set) == LARDON3D_FEATURE_STORE_OK;
free(keypoints);
free(descriptors);
return success;
}
static bool fixture_create(Fixture *fixture) {
memset(fixture, 0, sizeof(*fixture));
char root[] = "/tmp/lardon3d-matcher-task-XXXXXX";
char *created = mkdtemp(root);
if (!created ||
snprintf(fixture->root, sizeof(fixture->root), "%s", created) <= 0 ||
setenv("LARDON3D_PROJECTS_ROOT", fixture->root, 1) != 0) {
return false;
}
memset(fixture->feature_fingerprint, 0x5A,
sizeof(fixture->feature_fingerprint));
lardon3d_app_state_init(&fixture->state);
if (!create_runtime(&fixture->state) ||
!lardon3d_project_create(&fixture->state, "MatcherTask") ||
lardon3d_project_db_create_scanset(fixture->state.project_db,
"matcher-task", &fixture->scanset) !=
LARDON3D_PROJECT_DB_OK) {
return false;
}
for (size_t index = 0; index < IMAGE_COUNT; ++index) {
if (!register_image(fixture, (unsigned char)(index + 1), index) ||
!publish_features(fixture, index)) {
return false;
}
}
for (size_t index = 0; index < PAIR_COUNT; ++index) {
if (lardon3d_project_db_create_candidate_pair(
fixture->state.project_db, fixture->images[index].image_id,
fixture->images[index + 1].image_id, (int64_t)index,
&fixture->pairs[index]) != LARDON3D_PROJECT_DB_OK) {
return false;
}
}
char database_path[PATH_MAX];
if (!join_path(database_path, fixture->state.project_path, "project.db")) {
return false;
}
sqlite3 *connection = NULL;
if (sqlite3_open_v2(database_path, &connection, SQLITE_OPEN_READWRITE,
NULL) != SQLITE_OK) {
if (connection) {
sqlite3_close(connection);
}
return false;
}
char sql[128];
int written =
snprintf(sql, sizeof(sql),
"DELETE FROM candidate_pairs WHERE candidate_pair_id=%lu",
(unsigned long)fixture->pairs[2].candidate_pair_id);
bool deleted = written > 0 && (size_t)written < sizeof(sql) &&
sqlite3_exec(connection, sql, NULL, NULL, NULL) == SQLITE_OK &&
sqlite3_changes(connection) == 1;
(void)sqlite3_close(connection);
if (!deleted) {
return false;
}
return true;
}
static void stop_runtime(Fixture *fixture) {
if (fixture->state.task_queue) {
lardon3d_task_queue_destroy(fixture->state.task_queue);
fixture->state.task_queue = NULL;
}
lardon3d_project_close(&fixture->state);
if (fixture->state.resource_governor) {
lardon3d_resource_governor_destroy(fixture->state.resource_governor);
fixture->state.resource_governor = NULL;
}
lardon3d_orb_vulkan_backend_destroy(fixture->state.orb_vulkan_backend);
fixture->state.orb_vulkan_backend = NULL;
}
static bool reopen_runtime(Fixture *fixture) {
lardon3d_app_state_init(&fixture->state);
return create_runtime(&fixture->state) &&
lardon3d_project_open(&fixture->state, "MatcherTask");
}
static Lardon3DMatcherTaskConfiguration configuration(const Fixture *fixture) {
Lardon3DMatcherTaskConfiguration result = {
.feature_extractor_version = 1,
.matcher =
{
.kind = LARDON3D_MATCHER_ORB_BF,
.ratio_threshold = 0.75F,
},
};
(void)snprintf(result.feature_extractor_kind,
sizeof(result.feature_extractor_kind), "orb");
memcpy(result.feature_parameter_fingerprint, fixture->feature_fingerprint,
sizeof(result.feature_parameter_fingerprint));
return result;
}
static bool count_results(Fixture *fixture, size_t *count) {
Lardon3DProjectDbMatchResult results[16];
uint64_t cursor = 0;
*count = 0;
for (;;) {
size_t page_count = 0;
if (lardon3d_project_db_list_match_results(
fixture->state.project_db, cursor, results, 16, &page_count) !=
LARDON3D_PROJECT_DB_OK) {
return false;
}
*count += page_count;
if (page_count < 16) {
return true;
}
cursor = results[page_count - 1].match_result_id;
}
}
static bool same_estimate(const Lardon3DResourceEstimate *a,
const Lardon3DResourceEstimate *b) {
return a->memory_fixed_bytes == b->memory_fixed_bytes &&
a->gpu_memory_fixed_bytes == b->gpu_memory_fixed_bytes &&
a->memory_bytes_per_item == b->memory_bytes_per_item &&
a->gpu_memory_bytes_per_item == b->gpu_memory_bytes_per_item &&
a->minimum_batch_size == b->minimum_batch_size &&
a->maximum_batch_size == b->maximum_batch_size &&
a->desired_cpu_threads == b->desired_cpu_threads &&
a->desired_gpu_slots == b->desired_gpu_slots &&
a->desired_io_slots == b->desired_io_slots &&
a->task_class == b->task_class;
}
static bool run_completed_with_threads(Fixture *fixture,
Lardon3DMatcherTaskConfiguration settings,
unsigned int threads) {
char value[16];
(void)snprintf(value, sizeof(value), "%u", threads);
if (setenv("LARDON3D_TEST_MATCHER_CPU_THREADS", value, 1) != 0) return false;
uint64_t task_id = 0;
Lardon3DTaskSnapshot snapshot;
Lardon3DProjectDbTask durable;
bool success = lardon3d_project_enqueue_matcher_task_with_mode(
&fixture->state, &settings,
LARDON3D_MATCHER_TASK_MODE_CPU_PARALLEL, &task_id) &&
wait_state(fixture->state.task_queue, task_id, TASK_COMPLETED,
&snapshot) &&
snapshot.progress == 100 &&
wait_durable_state(fixture->state.project_db, task_id,
TASK_COMPLETED, &durable);
return unsetenv("LARDON3D_TEST_MATCHER_CPU_THREADS") == 0 && success;
}
static bool run_failed_at_pair(Fixture *fixture,
Lardon3DMatcherTaskConfiguration settings,
const char *failure_variable,
uint64_t failed_pair_id, size_t expected_prefix,
uint64_t expected_cursor) {
size_t before = 0;
if (!count_results(fixture, &before)) return false;
char value[32];
(void)snprintf(value, sizeof(value), "%lu", (unsigned long)failed_pair_id);
if (setenv(failure_variable, value, 1) != 0 ||
setenv("LARDON3D_TEST_MATCHER_CPU_THREADS", "4", 1) != 0) {
return false;
}
uint64_t task_id = 0;
Lardon3DTaskSnapshot snapshot;
bool failed = lardon3d_project_enqueue_matcher_task_with_mode(
&fixture->state, &settings,
LARDON3D_MATCHER_TASK_MODE_CPU_PARALLEL, &task_id) &&
wait_state(fixture->state.task_queue, task_id, TASK_FAILED,
&snapshot);
(void)unsetenv(failure_variable);
(void)unsetenv("LARDON3D_TEST_MATCHER_CPU_THREADS");
size_t after = 0;
Lardon3DProjectDbMatcherTask saved;
bool cursor_saved = false;
for (size_t attempt = 0; attempt < 2000000; ++attempt) {
if (lardon3d_project_db_load_matcher_task(fixture->state.project_db, task_id,
&saved) == LARDON3D_PROJECT_DB_OK &&
saved.after_candidate_pair_id == expected_cursor) {
cursor_saved = true;
break;
}
sched_yield();
}
return failed && cursor_saved && count_results(fixture, &after) &&
after == before + expected_prefix &&
saved.after_candidate_pair_id == expected_cursor;
}
#if defined(LARDON3D_MATCHER_TASK_VULKAN) && \
defined(LARDON3D_MATCHER_TASK_BENCHMARK_PIPELINE)
typedef struct {
size_t count;
Lardon3DProjectDbMatchResult results[PAIR_COUNT];
Lardon3DResourceSequenceDiagnostic diagnostic;
Lardon3DResourceSequenceAggregate aggregate;
size_t overlap_publications;
} PipelineEvidence;
#ifdef __linux__
enum { PROCESS_THREAD_SNAPSHOT_CAPACITY = 1024 };
typedef struct {
size_t count;
pid_t tids[PROCESS_THREAD_SNAPSHOT_CAPACITY];
} ProcessThreadSnapshot;
static bool parse_task_tid(const char *text, pid_t *tid) {
if (!text || !tid || text[0] < '0' || text[0] > '9') return false;
unsigned long value = 0;
const char *cursor = text;
do {
unsigned int digit = (unsigned int)(*cursor - '0');
if (value > (unsigned long)(INT_MAX - (int)digit) / 10) return false;
value = value * 10 + digit;
++cursor;
} while (*cursor >= '0' && *cursor <= '9');
if (*cursor != '\0' || value == 0) return false;
*tid = (pid_t)value;
return true;
}
static bool capture_process_thread_snapshot(ProcessThreadSnapshot *snapshot) {
if (!snapshot) return false;
*snapshot = (ProcessThreadSnapshot){0};
DIR *directory = opendir("/proc/self/task");
if (!directory) return false;
bool valid = true;
for (struct dirent *entry = readdir(directory); entry;
entry = readdir(directory)) {
pid_t tid = 0;
if (!parse_task_tid(entry->d_name, &tid)) continue;
if (snapshot->count == PROCESS_THREAD_SNAPSHOT_CAPACITY) {
valid = false;
break;
}
snapshot->tids[snapshot->count++] = tid;
}
return closedir(directory) == 0 && valid;
}
static bool thread_snapshot_contains(
const ProcessThreadSnapshot *snapshot, pid_t tid) {
for (size_t index = 0; index < snapshot->count; ++index) {
if (snapshot->tids[index] == tid) return true;
}
return false;
}
static bool read_thread_comm(pid_t tid, char comm[64]) {
char path[128];
int written = snprintf(path, sizeof(path), "/proc/self/task/%ld/comm",
(long)tid);
if (written <= 0 || (size_t)written >= sizeof(path)) return false;
int descriptor = open(path, O_RDONLY | O_CLOEXEC | O_NOFOLLOW);
if (descriptor < 0) return false;
ssize_t count = read(descriptor, comm, 63);
bool valid = count > 0 && count < 63 && read(descriptor, comm + count, 1) == 0;
if (close(descriptor) != 0) valid = false;
if (!valid) return false;
size_t length = (size_t)count;
while (length > 0 &&
(comm[length - 1] == '\n' || comm[length - 1] == '\r')) {
--length;
}
comm[length] = '\0';
return true;
}
static bool read_thread_cpu_list(pid_t tid, char output[256]) {
char path[128];
int written = snprintf(path, sizeof(path), "/proc/self/task/%ld/status",
(long)tid);
if (written <= 0 || (size_t)written >= sizeof(path)) return false;
int descriptor = open(path, O_RDONLY | O_CLOEXEC | O_NOFOLLOW);
if (descriptor < 0) return false;
char status[16384];
ssize_t count = read(descriptor, status, sizeof(status) - 1);
bool valid = count > 0 && count < (ssize_t)(sizeof(status) - 1) &&
read(descriptor, status + count, 1) == 0;
int saved_error = errno;
if (close(descriptor) != 0) valid = false;
if (!valid) {
errno = saved_error;
return false;
}
status[count] = '\0';
static const char prefix[] = "Cpus_allowed_list:";
char *line = strstr(status, prefix);
if (!line || (line != status && line[-1] != '\n')) return false;
line += sizeof(prefix) - 1;
while (*line == ' ' || *line == '\t') ++line;
char *end = strchr(line, '\n');
if (!end) return false;
while (end > line && (end[-1] == ' ' || end[-1] == '\t' ||
end[-1] == '\r')) {
--end;
}
size_t length = (size_t)(end - line);
if (length == 0 || length >= 256) return false;
memcpy(output, line, length);
output[length] = '\0';
return true;
}
static bool format_cpu_list(
const uint64_t mask[LARDON3D_RESOURCE_CPU_MASK_WORDS], char output[256]) {
size_t used = 0;
bool first = true;
for (unsigned int cpu = 0; cpu < LARDON3D_RESOURCE_CPU_MAX;) {
if ((mask[cpu / 64] & (UINT64_C(1) << (cpu % 64))) == 0) {
++cpu;
continue;
}
unsigned int begin = cpu;
while (cpu + 1 < LARDON3D_RESOURCE_CPU_MAX &&
(mask[(cpu + 1) / 64] &
(UINT64_C(1) << ((cpu + 1) % 64))) != 0) {
++cpu;
}
unsigned int end = cpu;
int written = snprintf(output + used, 256 - used,
first ? begin == end ? "%u" : "%u-%u"
: begin == end ? ",%u" : ",%u-%u",
begin, end);
if (written <= 0 || (size_t)written >= 256 - used) return false;
used += (size_t)written;
first = false;
++cpu;
}
return !first;
}
static bool verify_process_heavy_affinity(
Lardon3DResourceGovernor *governor,
const ProcessThreadSnapshot *before_threads,
const cpu_set_t *main_before) {
Lardon3DResourceCpuPolicyDiagnostic diagnostic;
if (!governor || !before_threads || !main_before
|| !lardon3d_resource_governor_internal_cpu_policy(
governor, &diagnostic)
|| !diagnostic.affinity_active
|| !diagnostic.runtime_thread_policy_active
|| !diagnostic.mesa_shader_cache_disabled) {
return false;
}
char expected_cpu_list[256];
if (!format_cpu_list(diagnostic.compute_mask, expected_cpu_list)) {
return false;
}
DIR *directory = opendir("/proc/self/task");
if (!directory) return false;
bool valid = true;
size_t non_main = 0;
size_t mesa_disk_threads = 0;
pid_t main_tid = getpid();
char main_comm[64];
char main_cpu_list[256];
if (!read_thread_comm(main_tid, main_comm)
|| !read_thread_cpu_list(main_tid, main_cpu_list)) {
valid = false;
} else {
(void)fprintf(stdout,
"thread_affinity_evidence tid=%ld comm=%s cpus=%s "
"role=main\n",
(long)main_tid, main_comm, main_cpu_list);
}
for (struct dirent *entry = readdir(directory); entry;
entry = readdir(directory)) {
pid_t tid = 0;
if (!parse_task_tid(entry->d_name, &tid) || tid == main_tid) continue;
char comm[64];
char cpu_list[256];
errno = 0;
if (!read_thread_comm(tid, comm) || !read_thread_cpu_list(tid, cpu_list)) {
if (errno == ESRCH || errno == ENOENT) continue;
valid = false;
break;
}
++non_main;
bool created_after_snapshot = !thread_snapshot_contains(before_threads, tid);
(void)fprintf(stdout,
"thread_affinity_evidence tid=%ld comm=%s cpus=%s "
"role=runtime new=%s\n",
(long)tid, comm, cpu_list,
created_after_snapshot ? "true" : "false");
if (strcmp(cpu_list, expected_cpu_list) != 0) valid = false;
if (strstr(comm, ":disk$") != NULL) ++mesa_disk_threads;
if (!valid) break;
}
if (closedir(directory) != 0) valid = false;
cpu_set_t main_after;
CPU_ZERO(&main_after);
if (sched_getaffinity(0, sizeof(main_after), &main_after) != 0
|| !CPU_EQUAL(main_before, &main_after)) {
valid = false;
}
/* The Queue worker is always present. On the verified 780M host, disabling
* Mesa's disk cache must eliminate the known affinity-widening disk helpers;
* every remaining live runtime thread must retain the worker compute pool. */
Lardon3DHardwareProfile host;
bool current_780m = lardon3d_hardware_profile_detect(&host, NULL, 0)
&& host.gpu_drm_card_index == 1 && host.gpu_uses_shared_memory
&& host.gpu_memory_known
&& host.gpu_memory_total_bytes == UINT64_C(536870912);
if (current_780m && mesa_disk_threads != 0) {
valid = false;
}
return valid && non_main >= 1;
}
#else
typedef struct {
bool unused;
} ProcessThreadSnapshot;
static bool capture_process_thread_snapshot(ProcessThreadSnapshot *snapshot) {
if (!snapshot) return false;
snapshot->unused = false;
return true;
}
static bool verify_process_heavy_affinity(
Lardon3DResourceGovernor *governor,
const ProcessThreadSnapshot *before_threads,
const cpu_set_t *main_before) {
(void)governor;
(void)before_threads;
(void)main_before;
return true;
}
#endif
static bool capture_pipeline_evidence(bool synchronous,
unsigned int inflight_override,
unsigned int batch_override,
PipelineEvidence *evidence) {
if (!evidence || (inflight_override != 1 && inflight_override != 2) ||
(batch_override != 0 && batch_override != 2 && batch_override != 4 &&
batch_override != 8 && batch_override != 12) ||
(synchronous && (inflight_override != 1 || batch_override != 0)))
return false;
Fixture fixture;
cpu_set_t main_before;
CPU_ZERO(&main_before);
if (sched_getaffinity(0, sizeof(main_before), &main_before) != 0) return false;
/* Keep enough consecutive eligible pairs for AUTO slow-start to reach a
* rolling batch greater than one without making the main CPU fixture heavy. */
if (setenv("LARDON3D_TEST_MATCHER_PIPELINE_FIXTURE", "1", 1) != 0 ||
!fixture_create(&fixture) ||
unsetenv("LARDON3D_TEST_MATCHER_PIPELINE_FIXTURE") != 0)
return false;
ProcessThreadSnapshot before_threads;
if (!capture_process_thread_snapshot(&before_threads)) {
stop_runtime(&fixture);
(void)remove_tree(fixture.root);
return false;
}
const char *inflight = inflight_override == 1 ? "1" : "2";
char batch[3];
int batch_length = snprintf(batch, sizeof(batch), "%u", batch_override);
bool configured =
(synchronous
? setenv(LARDON3D_MATCHER_TASK_BENCHMARK_SYNCHRONOUS_ENV, "1", 1)
: unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_SYNCHRONOUS_ENV)) == 0 &&
setenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV, inflight, 1) == 0 &&
(batch_override != 0
? batch_length > 0 && (size_t)batch_length < sizeof(batch) &&
setenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV, batch, 1) == 0
: unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV) == 0) &&
unsetenv("LARDON3D_TEST_MATCHER_INFLIGHT_LIMIT") == 0;
lardon3d_matcher_task_test_reset_backend_counters();
Lardon3DMatcherTaskConfiguration settings = configuration(&fixture);
uint64_t task_id = 0;
Lardon3DTaskSnapshot snapshot;
bool completed = configured && lardon3d_project_enqueue_matcher_task(
&fixture.state, &settings, &task_id) &&
wait_state(fixture.state.task_queue, task_id,
TASK_COMPLETED, &snapshot);
bool environment_restored =
unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_SYNCHRONOUS_ENV) == 0 &&
unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV) == 0 &&
unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV) == 0;
completed = environment_restored && completed;
uint64_t cursor = 0;
while (completed && evidence->count < PAIR_COUNT) {
size_t count = 0;
completed = lardon3d_project_db_list_match_results(
fixture.state.project_db, cursor,
evidence->results + evidence->count,
PAIR_COUNT - evidence->count, &count) ==
LARDON3D_PROJECT_DB_OK;
if (!completed || count == 0) break;
evidence->count += count;
cursor = evidence->results[evidence->count - 1].match_result_id;
}
evidence->overlap_publications =
lardon3d_matcher_task_test_overlap_publications();
completed = completed && evidence->count == PERSISTED_PAIR_COUNT &&
lardon3d_matcher_task_test_vulkan_uses() >= 2 &&
lardon3d_resource_governor_internal_last_diagnostic(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &evidence->diagnostic) &&
lardon3d_resource_governor_internal_sequence_aggregate(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &evidence->aggregate) &&
evidence->diagnostic.backend ==
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN &&
evidence->diagnostic.cpu_threads == 1 &&
evidence->diagnostic.gpu_slots == 1 &&
evidence->diagnostic.helper_limit == 0 &&
evidence->diagnostic.io_slots == 1 &&
evidence->diagnostic.batch_size ==
(batch_override != 0 ? batch_override : 2) &&
evidence->diagnostic.memory_bytes ==
(uint64_t)(batch_override != 0 ? batch_override : 2) *
10U * 1024U * 1024U &&
evidence->diagnostic.inflight_limit == inflight_override &&
evidence->diagnostic.gpu_memory_bytes ==
inflight_override * 640U * 1024U &&
evidence->aggregate.admission_count > 0 &&
evidence->aggregate.selected_backend_admissions[
LARDON3D_RESOURCE_BACKEND_CPU] == 0 &&
evidence->aggregate.selected_backend_admissions[
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN] ==
evidence->aggregate.admission_count &&
evidence->aggregate.contract_change_count == 0 &&
evidence->aggregate.backend_failure_fallback_sequences == 0 &&
evidence->aggregate.backend_other_fallback_sequences == 0 &&
evidence->aggregate.local_ineligible_fallback_items ==
PERSISTED_PAIR_COUNT - PIPELINE_ELIGIBLE_PAIR_COUNT &&
evidence->aggregate.backend_failure_fallback_items == 0 &&
evidence->aggregate.backend_other_fallback_items == 0 &&
verify_process_heavy_affinity(
fixture.state.resource_governor, &before_threads, &main_before);
stop_runtime(&fixture);
return remove_tree(fixture.root) && completed;
}
static bool same_pipeline_scientific_output(
const PipelineEvidence *rolling, const PipelineEvidence *synchronous) {
if (rolling->count != synchronous->count) return false;
for (size_t index = 0; index < rolling->count; ++index) {
const Lardon3DProjectDbMatchResult *left = &rolling->results[index];
const Lardon3DProjectDbMatchResult *right = &synchronous->results[index];
if (left->candidate_pair_id != right->candidate_pair_id ||
left->feature_set_id_a != right->feature_set_id_a ||
left->feature_set_id_b != right->feature_set_id_b ||
strcmp(left->matcher_kind, right->matcher_kind) != 0 ||
left->matcher_version != right->matcher_version ||
memcmp(left->parameter_fingerprint, right->parameter_fingerprint,
sizeof(left->parameter_fingerprint)) != 0 ||
left->result_status != right->result_status ||
left->match_count != right->match_count ||
left->has_match_asset != right->has_match_asset ||
memcmp(left->match_asset_sha256, right->match_asset_sha256,
sizeof(left->match_asset_sha256)) != 0 ||
left->match_asset_size_bytes != right->match_asset_size_bytes)
return false;
}
return true;
}
static bool same_forced_contract_except_depth(
const PipelineEvidence *depth_one, const PipelineEvidence *depth_two) {
const Lardon3DResourceSequenceDiagnostic *one = &depth_one->diagnostic;
const Lardon3DResourceSequenceDiagnostic *two = &depth_two->diagnostic;
return one->backend == LARDON3D_RESOURCE_BACKEND_ORB_VULKAN &&
two->backend == one->backend && one->cpu_threads == 1 &&
two->cpu_threads == one->cpu_threads && one->gpu_slots == 1 &&
two->gpu_slots == one->gpu_slots && one->batch_size == 2 &&
two->batch_size == one->batch_size && one->helper_limit == 0 &&
two->helper_limit == one->helper_limit &&
two->io_slots == one->io_slots && two->memory_bytes == one->memory_bytes &&
one->inflight_limit == 1 && two->inflight_limit == 2 &&
one->gpu_memory_bytes == 640U * 1024U &&
two->gpu_memory_bytes == 2U * 640U * 1024U;
}
static bool same_forced_contract_except_batch(
const PipelineEvidence *batch_two, const PipelineEvidence *other,
size_t expected_batch) {
const Lardon3DResourceSequenceDiagnostic *two = &batch_two->diagnostic;
const Lardon3DResourceSequenceDiagnostic *candidate = &other->diagnostic;
return two->backend == LARDON3D_RESOURCE_BACKEND_ORB_VULKAN &&
candidate->backend == two->backend && two->cpu_threads == 1 &&
candidate->cpu_threads == two->cpu_threads && two->gpu_slots == 1 &&
candidate->gpu_slots == two->gpu_slots && two->batch_size == 2 &&
candidate->batch_size == expected_batch && two->helper_limit == 0 &&
candidate->helper_limit == two->helper_limit &&
candidate->io_slots == two->io_slots && two->inflight_limit == 1 &&
candidate->inflight_limit == two->inflight_limit &&
two->gpu_memory_bytes == 640U * 1024U &&
candidate->gpu_memory_bytes == two->gpu_memory_bytes &&
two->memory_bytes == 2U * 10U * 1024U * 1024U &&
candidate->memory_bytes == expected_batch * 10U * 1024U * 1024U;
}
static bool forced_benchmark_fail_closed(void) {
if (unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV) != 0 ||
setenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV, "2", 1) != 0)
return false;
Fixture fixture;
if (!fixture_create(&fixture)) {
(void)unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV);
return false;
}
Lardon3DMatcherTaskConfiguration settings = configuration(&fixture);
uint64_t rejected_id = 0;
/* Build/GPU/backend are the only creation metadata. Memory failure belongs
* to the exact Governor boundary test above, not a divergent AppState copy. */
fixture.state.hardware_profile.gpu_available = false;
Lardon3DTask *gpu_rejected = lardon3d_project_create_matcher_task(
&fixture.state, &settings, &rejected_id);
fixture.state.hardware_profile.gpu_available = true;
bool ok = !gpu_rejected;
if (!ok) fprintf(stderr, "forced benchmark pre-admission rejection failed\n");
if (gpu_rejected) lardon3d_task_destroy(gpu_rejected);
/* Backend availability can disappear after creation but before admission.
* The one-capability forced envelope must be rejected, never admitted CPU. */
uint64_t unavailable_id = 0;
Lardon3DTask *unavailable = ok ? lardon3d_project_create_matcher_task(
&fixture.state, &settings, &unavailable_id) : NULL;
Lardon3DTaskSnapshot snapshot;
bool unavailable_added = unavailable &&
lardon3d_resource_governor_internal_set_backend_available(
fixture.state.resource_governor,
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN, false) &&
lardon3d_task_queue_add(fixture.state.task_queue, unavailable, NULL);
if (unavailable_added) unavailable = NULL;
ok = ok && unavailable_added &&
wait_state(fixture.state.task_queue, unavailable_id, TASK_FAILED,
&snapshot);
if (!ok) fprintf(stderr, "forced benchmark unavailable backend was not rejected\n");
if (unavailable) lardon3d_task_destroy(unavailable);
/* A failure after GPU admission may leave exact whole-pair CPU publications
* durable, but the benchmark Task itself must fail and classify the cohort
* as backend failure rather than local ineligibility. */
char failed_pair[32];
Lardon3DMatcherTaskConfiguration failing = settings;
failing.matcher.ratio_threshold = 0.74F;
uint64_t failing_id = 0;
ok = ok &&
lardon3d_resource_governor_internal_set_backend_available(
fixture.state.resource_governor,
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN, true) &&
snprintf(failed_pair, sizeof(failed_pair), "%lu",
(unsigned long)fixture.pairs[0].candidate_pair_id) > 0 &&
setenv("LARDON3D_TEST_MATCHER_FAIL_VULKAN_BEGIN_PAIR_ID",
failed_pair, 1) == 0 &&
lardon3d_project_enqueue_matcher_task(
&fixture.state, &failing, &failing_id) &&
wait_state(fixture.state.task_queue, failing_id, TASK_FAILED, &snapshot);
(void)unsetenv("LARDON3D_TEST_MATCHER_FAIL_VULKAN_BEGIN_PAIR_ID");
Lardon3DResourceSequenceAggregate aggregate;
Lardon3DResourceSequenceDiagnostic failing_diagnostic;
size_t failed_results = 0;
ok = ok && count_results(&fixture, &failed_results) && failed_results == 2 &&
lardon3d_resource_governor_internal_sequence_aggregate(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &aggregate) &&
lardon3d_resource_governor_internal_last_diagnostic(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &failing_diagnostic) &&
aggregate.admission_count == 1 && aggregate.sequence_count == 1 &&
aggregate.selected_backend_admissions[
LARDON3D_RESOURCE_BACKEND_CPU] == 0 &&
aggregate.selected_backend_admissions[
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN] == 1 &&
aggregate.backend_failure_fallback_sequences == 1 &&
aggregate.backend_ineligible_fallback_sequences == 0 &&
aggregate.backend_other_fallback_sequences == 0 &&
aggregate.local_ineligible_fallback_items == 0 &&
aggregate.backend_failure_fallback_items == failed_results &&
aggregate.backend_other_fallback_items == 0 &&
failing_diagnostic.execution.backend_failure_fallback_items ==
failed_results &&
failing_diagnostic.execution.local_ineligible_fallback_items == 0 &&
failing_diagnostic.execution.backend_other_fallback_items == 0;
if (!ok) {
fprintf(stderr,
"forced benchmark failure classification failed results=%zu "
"admissions=%lu sequences=%lu cpu=%lu vk=%lu actual_cpu=%lu "
"actual_vk=%lu actual_mixed=%lu fallbacks=%lu local=%lu "
"failure=%lu other=%lu local_items=%lu failure_items=%lu "
"other_items=%lu reason=%s\n",
failed_results, (unsigned long)aggregate.admission_count,
(unsigned long)aggregate.sequence_count,
(unsigned long)aggregate.selected_backend_admissions[
LARDON3D_RESOURCE_BACKEND_CPU],
(unsigned long)aggregate.selected_backend_admissions[
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN],
(unsigned long)aggregate.actual_backend_sequences[
LARDON3D_RESOURCE_BACKEND_CPU],
(unsigned long)aggregate.actual_backend_sequences[
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN],
(unsigned long)aggregate.actual_backend_sequences[
LARDON3D_RESOURCE_BACKEND_MIXED],
(unsigned long)aggregate.backend_fallback_sequences,
(unsigned long)aggregate.backend_ineligible_fallback_sequences,
(unsigned long)aggregate.backend_failure_fallback_sequences,
(unsigned long)aggregate.backend_other_fallback_sequences,
(unsigned long)aggregate.local_ineligible_fallback_items,
(unsigned long)aggregate.backend_failure_fallback_items,
(unsigned long)aggregate.backend_other_fallback_items,
failing_diagnostic.backend_reason);
}
Lardon3DMatcherTaskConfiguration following = settings;
following.matcher.ratio_threshold = 0.73F;
uint64_t following_id = 0;
bool availability_restored =
lardon3d_resource_governor_internal_set_backend_available(
fixture.state.resource_governor,
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN, true);
bool following_enqueued = availability_restored &&
lardon3d_project_enqueue_matcher_task(
&fixture.state, &following, &following_id);
bool following_completed = following_enqueued &&
wait_state(fixture.state.task_queue, following_id, TASK_COMPLETED,
&snapshot);
bool following_aggregate = following_completed &&
lardon3d_resource_governor_internal_sequence_aggregate(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &aggregate);
ok = ok && following_aggregate && aggregate.admission_count > 1 &&
aggregate.selected_backend_admissions[
LARDON3D_RESOURCE_BACKEND_CPU] == 0 &&
aggregate.selected_backend_admissions[
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN] ==
aggregate.admission_count &&
aggregate.backend_failure_fallback_sequences == 1 &&
aggregate.backend_other_fallback_sequences == 0 &&
aggregate.backend_failure_fallback_items == failed_results &&
aggregate.backend_other_fallback_items == 0;
if (!ok) {
fprintf(stderr,
"forced benchmark backend reuse failed available=%d enqueue=%d "
"completed=%d aggregate=%d state=%d admissions=%lu cpu=%lu vk=%lu\n",
availability_restored, following_enqueued, following_completed,
following_aggregate, (int)snapshot.state,
(unsigned long)aggregate.admission_count,
(unsigned long)aggregate.selected_backend_admissions[
LARDON3D_RESOURCE_BACKEND_CPU],
(unsigned long)aggregate.selected_backend_admissions[
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN]);
}
bool environment_restored =
unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV) == 0 &&
unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV) == 0;
stop_runtime(&fixture);
return remove_tree(fixture.root) && environment_restored && ok;
}
static bool pair_local_neighbor_failure_case(const char *failure_variable) {
Fixture fixture;
if (!failure_variable || !fixture_create(&fixture)) return false;
char local_pair[32];
char failed_pair[32];
bool configured =
snprintf(local_pair, sizeof(local_pair), "%lu",
(unsigned long)fixture.pairs[0].candidate_pair_id) > 0 &&
snprintf(failed_pair, sizeof(failed_pair), "%lu",
(unsigned long)fixture.pairs[1].candidate_pair_id) > 0 &&
unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_SYNCHRONOUS_ENV) == 0 &&
setenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV, "2", 1) == 0 &&
setenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV, "2", 1) == 0 &&
setenv("LARDON3D_TEST_MATCHER_INELIGIBLE_VULKAN_BEGIN_PAIR_ID",
local_pair, 1) == 0 &&
setenv(failure_variable, failed_pair, 1) == 0;
Lardon3DMatcherTaskConfiguration settings = configuration(&fixture);
uint64_t task_id = 0;
Lardon3DTaskSnapshot snapshot;
bool failed = configured && lardon3d_project_enqueue_matcher_task(
&fixture.state, &settings, &task_id) &&
wait_state(fixture.state.task_queue, task_id, TASK_FAILED, &snapshot);
Lardon3DResourceSequenceAggregate aggregate = {0};
Lardon3DResourceSequenceDiagnostic diagnostic = {0};
size_t result_count = 0;
bool exact = failed && count_results(&fixture, &result_count) &&
result_count == 2 &&
lardon3d_resource_governor_internal_sequence_aggregate(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &aggregate) &&
lardon3d_resource_governor_internal_last_diagnostic(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &diagnostic) &&
aggregate.sequence_count == 1 && aggregate.durable_items == 2 &&
aggregate.local_ineligible_fallback_items == 1 &&
aggregate.backend_failure_fallback_items == 1 &&
aggregate.backend_other_fallback_items == 0 &&
diagnostic.execution.local_ineligible_fallback_items == 1 &&
diagnostic.execution.backend_failure_fallback_items == 1 &&
diagnostic.execution.backend_other_fallback_items == 0;
(void)unsetenv(failure_variable);
(void)unsetenv("LARDON3D_TEST_MATCHER_INELIGIBLE_VULKAN_BEGIN_PAIR_ID");
(void)unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV);
(void)unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV);
stop_runtime(&fixture);
return remove_tree(fixture.root) && exact;
}
static bool local_vulkan_failure_preserves_backend_case(
const char *failure_variable, bool pre_submit) {
Fixture fixture;
if (!failure_variable || !fixture_create(&fixture)) return false;
char first_pair[32];
bool configured =
snprintf(first_pair, sizeof(first_pair), "%lu",
(unsigned long)fixture.pairs[0].candidate_pair_id) > 0 &&
unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_SYNCHRONOUS_ENV) == 0 &&
setenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV, "2", 1) == 0 &&
setenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV, "2", 1) == 0 &&
setenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_BATCH", "1", 1) == 0 &&
setenv(failure_variable, first_pair, 1) == 0;
Lardon3DOrbVulkanTelemetry telemetry_before = {0};
Lardon3DOrbVulkanTelemetry telemetry_after = {0};
configured = configured && lardon3d_orb_vulkan_internal_telemetry(
fixture.state.orb_vulkan_backend, &telemetry_before);
lardon3d_matcher_task_test_reset_backend_counters();
Lardon3DMatcherTaskConfiguration settings = configuration(&fixture);
settings.matcher.ratio_threshold = pre_submit ? 0.611F : 0.612F;
uint64_t task_id = 0;
Lardon3DTaskSnapshot snapshot;
bool paused = configured && lardon3d_project_enqueue_matcher_task(
&fixture.state, &settings, &task_id) &&
wait_state(fixture.state.task_queue, task_id, TASK_PAUSED, &snapshot);
Lardon3DResourceSequenceAggregate aggregate = {0};
Lardon3DResourceSequenceDiagnostic diagnostic = {0};
Lardon3DOrbVulkanInfo backend_info = {0};
size_t first_submit = 0;
size_t first_finish = 0;
size_t successor_submit = 0;
size_t successor_finish = 0;
bool first_submitted = find_test_event(
TEST_EVENT_GPU_SUBMIT, fixture.pairs[0].candidate_pair_id,
&first_submit);
bool first_finished = find_test_event(
TEST_EVENT_GPU_FINISH, fixture.pairs[0].candidate_pair_id,
&first_finish);
bool successor_submitted = find_test_event(
TEST_EVENT_GPU_SUBMIT, fixture.pairs[1].candidate_pair_id,
&successor_submit);
bool successor_finished = find_test_event(
TEST_EVENT_GPU_FINISH, fixture.pairs[1].candidate_pair_id,
&successor_finish);
/* The injected fault is deliberately outside Vulkan. The first durable
* sequence must use a complete CPU fallback, retain an unrelated submitted
* successor, and classify exactly one OTHER item without poisoning shared
* backend health or leaking a request-bound slot. */
bool exact = paused &&
lardon3d_resource_governor_internal_sequence_aggregate(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &aggregate) &&
lardon3d_resource_governor_internal_last_diagnostic(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &diagnostic) &&
lardon3d_orb_vulkan_internal_telemetry(
fixture.state.orb_vulkan_backend, &telemetry_after) &&
lardon3d_orb_vulkan_backend_info(
fixture.state.orb_vulkan_backend, &backend_info) &&
aggregate.sequence_count == 1 && aggregate.durable_items == 2 &&
aggregate.backend_failure_fallback_sequences == 0 &&
aggregate.backend_other_fallback_sequences == 1 &&
aggregate.local_ineligible_fallback_items == 0 &&
aggregate.backend_failure_fallback_items == 0 &&
aggregate.backend_other_fallback_items == 1 &&
diagnostic.backend == LARDON3D_RESOURCE_BACKEND_ORB_VULKAN &&
diagnostic.actual_backend == LARDON3D_RESOURCE_BACKEND_MIXED &&
diagnostic.backend_fallback &&
diagnostic.execution.local_ineligible_fallback_items == 0 &&
diagnostic.execution.backend_failure_fallback_items == 0 &&
diagnostic.execution.backend_other_fallback_items == 1 &&
strcmp(diagnostic.backend_reason,
"vulkan-and-local-failure-cpu-fallback") == 0 &&
successor_submitted && successor_finished &&
(pre_submit ? !first_submitted && !first_finished
: first_submitted && first_finished) &&
telemetry_after.submits == telemetry_before.submits +
(pre_submit ? 1U : 2U) &&
telemetry_after.completions == telemetry_before.completions +
(pre_submit ? 1U : 2U) &&
telemetry_after.failures == telemetry_before.failures &&
telemetry_after.discards == telemetry_before.discards &&
telemetry_after.pending_slots == 0 && !telemetry_after.slot_pending &&
backend_info.available &&
lardon3d_matcher_task_test_overlap_publications() >= 1 &&
no_staged_match_temporaries(&fixture);
bool resumed = unsetenv(failure_variable) == 0 &&
unsetenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_BATCH") == 0 &&
lardon3d_task_queue_resume(fixture.state.task_queue, task_id) &&
wait_state(fixture.state.task_queue, task_id, TASK_COMPLETED, &snapshot);
size_t first_task_results = 0;
exact = exact && resumed && count_results(&fixture, &first_task_results) &&
first_task_results == PERSISTED_PAIR_COUNT;
/* A fresh AUTO Task is the Governor-level health proof. It must still
* select the Vulkan arm and reuse the exact slots after the local fault. */
bool overrides_cleared =
unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV) == 0 &&
unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV) == 0;
lardon3d_matcher_task_test_reset_backend_counters();
Lardon3DMatcherTaskConfiguration following = configuration(&fixture);
following.matcher.ratio_threshold = pre_submit ? 0.613F : 0.614F;
uint64_t following_id = 0;
size_t final_results = 0;
exact = exact && overrides_cleared &&
lardon3d_project_enqueue_matcher_task(
&fixture.state, &following, &following_id) &&
wait_state(fixture.state.task_queue, following_id,
TASK_COMPLETED, &snapshot) &&
lardon3d_matcher_task_test_vulkan_uses() >= 2 &&
lardon3d_resource_governor_internal_last_diagnostic(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &diagnostic) &&
diagnostic.backend == LARDON3D_RESOURCE_BACKEND_ORB_VULKAN &&
diagnostic.gpu_slots == 1 &&
lardon3d_resource_governor_internal_sequence_aggregate(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &aggregate) &&
aggregate.backend_failure_fallback_sequences == 0 &&
aggregate.backend_failure_fallback_items == 0 &&
aggregate.backend_other_fallback_items == 1 &&
count_results(&fixture, &final_results) &&
final_results == 2 * PERSISTED_PAIR_COUNT &&
lardon3d_orb_vulkan_backend_info(
fixture.state.orb_vulkan_backend, &backend_info) &&
backend_info.available && no_staged_match_temporaries(&fixture);
(void)unsetenv(failure_variable);
(void)unsetenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_BATCH");
(void)unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_SYNCHRONOUS_ENV);
(void)unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV);
(void)unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV);
stop_runtime(&fixture);
return remove_tree(fixture.root) && exact;
}
typedef enum {
PREFIX_EXIT_CANCEL = 0,
PREFIX_EXIT_COMPUTE_FAILURE,
PREFIX_EXIT_PUBLICATION_FAILURE,
} PrefixExit;
static bool durable_fallback_prefix_case(bool synchronous, PrefixExit exit) {
Fixture fixture;
if (!fixture_create(&fixture)) return false;
char first_pair[32];
char second_pair[32];
bool configured =
snprintf(first_pair, sizeof(first_pair), "%lu",
(unsigned long)fixture.pairs[0].candidate_pair_id) > 0 &&
snprintf(second_pair, sizeof(second_pair), "%lu",
(unsigned long)fixture.pairs[1].candidate_pair_id) > 0 &&
(synchronous
? setenv(LARDON3D_MATCHER_TASK_BENCHMARK_SYNCHRONOUS_ENV, "1", 1)
: unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_SYNCHRONOUS_ENV)) == 0 &&
setenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV,
synchronous ? "1" : "2", 1) == 0 &&
unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV) == 0 &&
setenv("LARDON3D_TEST_MATCHER_INELIGIBLE_VULKAN_BEGIN_PAIR_ID",
first_pair, 1) == 0;
if (configured && exit == PREFIX_EXIT_CANCEL) {
configured = setenv(
"LARDON3D_TEST_MATCHER_PAUSE_AFTER_PUBLICATION", "1", 1) == 0;
} else if (configured && exit == PREFIX_EXIT_COMPUTE_FAILURE) {
configured =
setenv("LARDON3D_TEST_MATCHER_FAIL_VULKAN_BEGIN_PAIR_ID",
second_pair, 1) == 0 &&
setenv("LARDON3D_TEST_MATCHER_FAIL_COMPUTE_PAIR_ID",
second_pair, 1) == 0;
} else if (configured) {
configured =
setenv("LARDON3D_TEST_MATCHER_FAIL_VULKAN_BEGIN_PAIR_ID",
second_pair, 1) == 0 &&
setenv("LARDON3D_TEST_MATCHER_FAIL_PUBLISH_PAIR_ID",
second_pair, 1) == 0;
}
Lardon3DMatcherTaskConfiguration settings = configuration(&fixture);
uint64_t task_id = 0;
Lardon3DTaskSnapshot snapshot;
bool ended = configured && lardon3d_project_enqueue_matcher_task(
&fixture.state, &settings, &task_id);
if (ended && exit == PREFIX_EXIT_CANCEL) {
ended = wait_state(fixture.state.task_queue, task_id, TASK_PAUSED,
&snapshot) &&
lardon3d_task_queue_cancel(fixture.state.task_queue, task_id) &&
wait_state(fixture.state.task_queue, task_id, TASK_CANCELLED,
&snapshot);
} else if (ended) {
ended = wait_state(fixture.state.task_queue, task_id, TASK_FAILED,
&snapshot);
}
Lardon3DResourceSequenceAggregate aggregate = {0};
size_t result_count = 0;
/* The first fallback is durable; the second pair never reaches that
* boundary. Failed/cancelled work must retain one item without manufacturing
* a successful throughput sequence or durable-item rate observation. */
bool exact = ended && count_results(&fixture, &result_count) &&
result_count == 1 &&
lardon3d_resource_governor_internal_sequence_aggregate(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &aggregate) &&
aggregate.local_ineligible_fallback_items == 1 &&
aggregate.backend_failure_fallback_items == 0 &&
aggregate.backend_other_fallback_items == 0 &&
aggregate.sequence_count == 0 && aggregate.durable_items == 0;
(void)unsetenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_PUBLICATION");
(void)unsetenv("LARDON3D_TEST_MATCHER_FAIL_VULKAN_BEGIN_PAIR_ID");
(void)unsetenv("LARDON3D_TEST_MATCHER_FAIL_COMPUTE_PAIR_ID");
(void)unsetenv("LARDON3D_TEST_MATCHER_FAIL_PUBLISH_PAIR_ID");
(void)unsetenv("LARDON3D_TEST_MATCHER_INELIGIBLE_VULKAN_BEGIN_PAIR_ID");
(void)unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_SYNCHRONOUS_ENV);
(void)unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV);
(void)unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV);
stop_runtime(&fixture);
return remove_tree(fixture.root) && exact;
}
#endif
static bool run_test(void) {
CHECK(matcher_exact_memory_boundary_test());
Fixture fixture;
CHECK(fixture_create(&fixture));
char database_path[PATH_MAX];
CHECK(join_path(database_path, fixture.state.project_path, "project.db"));
stop_runtime(&fixture);
CHECK(downgrade_project_to_historical_v10(database_path));
CHECK(query_integer(database_path,
"SELECT value FROM metadata WHERE key='schema_version'",
10));
CHECK(
query_integer(database_path,
"SELECT count(*) FROM sqlite_master WHERE type='table' AND "
"name='match_results'",
1));
CHECK(
query_integer(database_path,
"SELECT count(*) FROM sqlite_master WHERE type='table' AND "
"name='matcher_tasks'",
0));
CHECK(reopen_runtime(&fixture));
CHECK(lardon3d_project_db_schema_version(fixture.state.project_db) ==
LARDON3D_PROJECT_DB_SCHEMA_VERSION);
CHECK(
query_integer(database_path,
"SELECT count(*) FROM sqlite_master WHERE type='table' AND "
"name='matcher_tasks'",
1));
const Lardon3DTaskKindRegistry *registry =
lardon3d_task_kind_registry_production();
const Lardon3DTaskKindDescriptor *descriptor = NULL;
CHECK(lardon3d_task_kind_registry_lookup(registry, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION,
&descriptor) ==
LARDON3D_TASK_KIND_OK &&
descriptor != NULL);
Lardon3DMatcherTaskConfiguration settings = configuration(&fixture);
#ifdef LARDON3D_MATCHER_TASK_BENCHMARK_PIPELINE
/* Malformed runner-private controls must fail Task construction rather than
* silently selecting an adaptive or partially tagged capability. */
uint64_t invalid_benchmark_task_id = 99;
CHECK(setenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV, "01", 1) == 0);
Lardon3DTask *invalid_benchmark_task =
lardon3d_project_create_matcher_task(
&fixture.state, &settings, &invalid_benchmark_task_id);
CHECK(invalid_benchmark_task == NULL && invalid_benchmark_task_id == 0 &&
unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV) == 0);
CHECK(setenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV, "1", 1) == 0 &&
setenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV, "3", 1) == 0);
invalid_benchmark_task_id = 99;
invalid_benchmark_task = lardon3d_project_create_matcher_task(
&fixture.state, &settings, &invalid_benchmark_task_id);
CHECK(invalid_benchmark_task == NULL && invalid_benchmark_task_id == 0 &&
unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_INFLIGHT_ENV) == 0 &&
unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV) == 0);
CHECK(setenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV, "4", 1) == 0);
invalid_benchmark_task_id = 99;
invalid_benchmark_task = lardon3d_project_create_matcher_task(
&fixture.state, &settings, &invalid_benchmark_task_id);
CHECK(invalid_benchmark_task == NULL && invalid_benchmark_task_id == 0 &&
unsetenv(LARDON3D_MATCHER_TASK_BENCHMARK_BATCH_ENV) == 0);
#endif
Lardon3DMatcherTaskConfiguration invalid = settings;
invalid.matcher.kind = LARDON3D_MATCHER_SIFT_BF;
uint64_t invalid_task_id = 0;
CHECK(!lardon3d_project_create_matcher_task(&fixture.state, &invalid,
&invalid_task_id));
CHECK(invalid_task_id == 0);
CHECK(setenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_PUBLICATION", "1", 1) == 0);
CHECK(setenv("LARDON3D_TEST_MATCHER_SKIP_FINISHED_CHECKPOINT", "1", 1) == 0);
uint64_t task_id = 0;
const uint64_t original_memory_total =
fixture.state.hardware_profile.memory_total_bytes;
const uint64_t depth_one_maximum_total =
UINT64_C(3) * 1024 * 1024 * 1024 +
UINT64_C(8) * 10 * 1024 * 1024 + UINT64_C(640) * 1024;
fixture.state.hardware_profile.memory_total_bytes = depth_one_maximum_total;
Lardon3DTask *first_auto = lardon3d_project_create_matcher_task(
&fixture.state, &settings, &task_id);
fixture.state.hardware_profile.memory_total_bytes = original_memory_total;
Lardon3DOrbVulkanInfo before_auto;
CHECK(first_auto && lardon3d_orb_vulkan_backend_info(
fixture.state.orb_vulkan_backend, &before_auto)
&& !before_auto.initialized);
/* Normal creation at the exact depth-1/batch-8 UMA boundary has exposed
* metadata only. The removed depth-2 caller guess would suppress it here;
* the first possible initialization remains begin() on the Queue worker. */
CHECK(lardon3d_task_queue_add(
fixture.state.task_queue, first_auto, NULL));
Lardon3DTaskSnapshot snapshot;
CHECK(wait_state(fixture.state.task_queue, task_id, TASK_PAUSED, &snapshot));
Lardon3DOrbVulkanInfo after_auto;
CHECK(lardon3d_orb_vulkan_backend_info(
fixture.state.orb_vulkan_backend, &after_auto));
#ifdef LARDON3D_MATCHER_TASK_VULKAN
CHECK(after_auto.initialized);
#else
CHECK(!after_auto.initialized);
#endif
size_t result_count = 0;
CHECK(count_results(&fixture, &result_count) && result_count == 1);
Lardon3DProjectDbMatcherTask saved;
CHECK(lardon3d_project_db_load_matcher_task(fixture.state.project_db, task_id,
&saved) ==
LARDON3D_PROJECT_DB_OK);
CHECK(saved.after_candidate_pair_id == 0);
CHECK(saved.matcher_kind == LARDON3D_MATCHER_ORB_BF);
CHECK(saved.ratio_threshold == 0.75F);
stop_runtime(&fixture);
CHECK(unsetenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_PUBLICATION") == 0);
CHECK(unsetenv("LARDON3D_TEST_MATCHER_SKIP_FINISHED_CHECKPOINT") == 0);
CHECK(reopen_runtime(&fixture));
Lardon3DProjectRecoverySummary recovery;
CHECK(lardon3d_project_last_recovery_summary(&fixture.state, &recovery));
CHECK(recovery.resumed == 1);
CHECK(
wait_state(fixture.state.task_queue, task_id, TASK_COMPLETED, &snapshot));
CHECK(snapshot.progress == 100);
Lardon3DProjectDbTask durable_task;
CHECK(wait_durable_state(fixture.state.project_db, task_id, TASK_COMPLETED,
&durable_task));
CHECK(durable_task.sequence_count >= 1);
CHECK(count_results(&fixture, &result_count) &&
result_count == PERSISTED_PAIR_COUNT);
CHECK(lardon3d_project_db_load_matcher_task(fixture.state.project_db, task_id,
&saved) ==
LARDON3D_PROJECT_DB_OK);
CHECK(saved.after_candidate_pair_id ==
fixture.pairs[PAIR_COUNT - 1].candidate_pair_id);
CHECK(setenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_PUBLICATION", "1", 1) == 0);
CHECK(setenv("LARDON3D_TEST_MATCHER_INFLIGHT_LIMIT", "2", 1) == 0);
uint64_t cancelled_id = 0;
CHECK(lardon3d_project_enqueue_matcher_task(&fixture.state, &settings,
&cancelled_id));
CHECK(unsetenv("LARDON3D_TEST_MATCHER_INFLIGHT_LIMIT") == 0);
CHECK(wait_state(fixture.state.task_queue, cancelled_id, TASK_PAUSED,
&snapshot));
CHECK(lardon3d_task_queue_cancel(fixture.state.task_queue, cancelled_id));
CHECK(wait_state(fixture.state.task_queue, cancelled_id, TASK_CANCELLED,
&snapshot));
CHECK(unsetenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_PUBLICATION") == 0);
CHECK(setenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_PUBLICATION", "1", 1) == 0);
uint64_t resumed_id = 0;
CHECK(lardon3d_project_enqueue_matcher_task(&fixture.state, &settings,
&resumed_id));
CHECK(
wait_state(fixture.state.task_queue, resumed_id, TASK_PAUSED, &snapshot));
CHECK(unsetenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_PUBLICATION") == 0);
CHECK(lardon3d_task_queue_resume(fixture.state.task_queue, resumed_id));
CHECK(wait_state(fixture.state.task_queue, resumed_id, TASK_COMPLETED,
&snapshot));
CHECK(setenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_BATCH", "1", 1) == 0);
uint64_t pressure_id = 0;
CHECK(lardon3d_project_enqueue_matcher_task(&fixture.state, &settings,
&pressure_id));
CHECK(wait_state(fixture.state.task_queue, pressure_id, TASK_PAUSED,
&snapshot));
Lardon3DResourcePolicy pressure_policy = interactive_policy();
pressure_policy.system_memory_reserve_bytes =
/* CPU12 reserves at most twelve 10 MiB staged-pair working sets; leave
* less than that available so the paused task must wait for a safe
* re-admission rather than silently exceeding its Governor contract. */
fixture.state.hardware_profile.memory_total_bytes - 128ULL * 1024 * 1024;
pressure_policy.emergency_memory_floor_bytes =
pressure_policy.system_memory_reserve_bytes;
CHECK(lardon3d_resource_governor_set_policy(fixture.state.resource_governor,
&pressure_policy));
CHECK(unsetenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_BATCH") == 0);
CHECK(lardon3d_task_queue_resume(fixture.state.task_queue, pressure_id));
for (size_t attempt = 0; attempt < 2000000; ++attempt) {
if (lardon3d_resource_governor_pressure(fixture.state.resource_governor) ==
LARDON3D_RESOURCE_PRESSURE_RED) {
break;
}
sched_yield();
}
CHECK(lardon3d_resource_governor_pressure(fixture.state.resource_governor) ==
LARDON3D_RESOURCE_PRESSURE_RED);
Lardon3DResourcePolicy normal_policy = interactive_policy();
CHECK(lardon3d_resource_governor_set_policy(fixture.state.resource_governor,
&normal_policy));
CHECK(wait_state(fixture.state.task_queue, pressure_id, TASK_COMPLETED,
&snapshot));
/* Thread-count changes are operational only: all five runs must publish
* the same Candidate Pair cardinality and identical raw Match evidence. */
CHECK(lardon3d_feature_opencv_configure_threads(3));
size_t equivalence_before = 0;
CHECK(count_results(&fixture, &equivalence_before));
Lardon3DMatcherTaskConfiguration one = settings;
one.matcher.ratio_threshold = 0.80F;
CHECK(run_completed_with_threads(&fixture, one, 1));
Lardon3DMatcherTaskConfiguration two = settings;
two.matcher.ratio_threshold = 0.81F;
CHECK(run_completed_with_threads(&fixture, two, 2));
Lardon3DMatcherTaskConfiguration four = settings;
four.matcher.ratio_threshold = 0.82F;
CHECK(run_completed_with_threads(&fixture, four, 4));
Lardon3DMatcherTaskConfiguration eight = settings;
eight.matcher.ratio_threshold = 0.84F;
CHECK(run_completed_with_threads(&fixture, eight, 8));
Lardon3DMatcherTaskConfiguration twelve = settings;
twelve.matcher.ratio_threshold = 0.85F;
CHECK(run_completed_with_threads(&fixture, twelve, 12));
size_t equivalence_after = 0;
CHECK(count_results(&fixture, &equivalence_after));
CHECK(equivalence_after == equivalence_before + 5 * PERSISTED_PAIR_COUNT);
CHECK(lardon3d_feature_opencv_thread_count() == 3);
Lardon3DResourceSequenceDiagnostic cpu_item_diagnostic;
CHECK(lardon3d_resource_governor_internal_last_diagnostic(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &cpu_item_diagnostic) &&
cpu_item_diagnostic.backend == LARDON3D_RESOURCE_BACKEND_CPU &&
cpu_item_diagnostic.actual_backend == LARDON3D_RESOURCE_BACKEND_CPU &&
cpu_item_diagnostic.execution.local_ineligible_fallback_items == 0 &&
cpu_item_diagnostic.execution.backend_failure_fallback_items == 0 &&
cpu_item_diagnostic.execution.backend_other_fallback_items == 0);
CHECK(candidate_results_have_one_evidence(
database_path, fixture.pairs[0].candidate_pair_id));
/* Explicit GPU selection is operational only. A real Queue admission must
* reserve the exact GPU shape and dispatch the first 769x769 ORB pair to
* Vulkan; all Match evidence remains byte-identical to the CPU runs above. */
#ifdef LARDON3D_MATCHER_TASK_VULKAN
/* Normal ORB is AUTO. The validated runtime must select GPU first, while
* retaining the canonical CPU durable estimate and identical evidence. */
lardon3d_matcher_task_test_reset_backend_counters();
Lardon3DMatcherTaskConfiguration automatic = settings;
automatic.matcher.ratio_threshold = 0.69F;
uint64_t automatic_id = 0;
CHECK(lardon3d_project_enqueue_matcher_task(
&fixture.state, &automatic, &automatic_id));
CHECK(wait_state(fixture.state.task_queue, automatic_id, TASK_COMPLETED,
&snapshot));
CHECK(lardon3d_matcher_task_test_vulkan_uses() >= 1);
Lardon3DResourceSequenceDiagnostic automatic_diagnostic;
CHECK(lardon3d_resource_governor_internal_last_diagnostic(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &automatic_diagnostic));
CHECK(automatic_diagnostic.backend ==
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN &&
automatic_diagnostic.helper_limit == 0 &&
automatic_diagnostic.gpu_slots == 1 &&
automatic_diagnostic.inflight_limit == 1 &&
automatic_diagnostic.gpu_memory_bytes == 640U * 1024U &&
automatic_diagnostic.reason[0] != '\0' &&
automatic_diagnostic.backend_reason[0] != '\0');
if (automatic_diagnostic.actual_backend ==
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN) {
CHECK(!automatic_diagnostic.backend_fallback &&
automatic_diagnostic.execution.vulkan_submits >= 1 &&
automatic_diagnostic.execution.vulkan_completions >= 1 &&
automatic_diagnostic.execution.publication_ns > 0 &&
strcmp(automatic_diagnostic.backend_reason,
"vulkan-completed") == 0);
} else {
/* Tiny fixture pairs are below the validated Vulkan threshold. They are
* complete CPU pairs inside a GPU-selected sequence, not backend failure. */
CHECK(automatic_diagnostic.backend_fallback &&
(automatic_diagnostic.actual_backend ==
LARDON3D_RESOURCE_BACKEND_CPU ||
automatic_diagnostic.actual_backend ==
LARDON3D_RESOURCE_BACKEND_MIXED));
}
/* A successor rejected as locally ineligible has no pending handle. The
* first sequence must finish that complete pair on CPU, retain backend
* health, and leave an already-created AUTO Task eligible for GPU admission. */
char ineligible_pair[32];
CHECK(snprintf(ineligible_pair, sizeof(ineligible_pair), "%lu",
(unsigned long)fixture.pairs[1].candidate_pair_id) > 0 &&
setenv("LARDON3D_TEST_MATCHER_INELIGIBLE_VULKAN_BEGIN_PAIR_ID",
ineligible_pair, 1) == 0 &&
setenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_BATCH", "1", 1) == 0);
Lardon3DMatcherTaskConfiguration local_ineligible = settings;
local_ineligible.matcher.ratio_threshold = 0.687F;
uint64_t local_ineligible_id = 0;
Lardon3DTask *local_ineligible_task =
lardon3d_project_create_matcher_task_with_mode(
&fixture.state, &local_ineligible,
LARDON3D_MATCHER_TASK_MODE_ORB_VULKAN, &local_ineligible_id);
Lardon3DMatcherTaskConfiguration auto_after_ineligible = settings;
auto_after_ineligible.matcher.ratio_threshold = 0.686F;
uint64_t auto_after_ineligible_id = 0;
Lardon3DTask *auto_after_ineligible_task =
lardon3d_project_create_matcher_task(
&fixture.state, &auto_after_ineligible,
&auto_after_ineligible_id);
CHECK(local_ineligible_task && auto_after_ineligible_task &&
lardon3d_task_queue_add(fixture.state.task_queue,
local_ineligible_task, NULL) &&
wait_state(fixture.state.task_queue, local_ineligible_id,
TASK_PAUSED, &snapshot));
Lardon3DResourceSequenceDiagnostic ineligible_diagnostic;
CHECK(lardon3d_resource_governor_internal_last_diagnostic(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &ineligible_diagnostic) &&
ineligible_diagnostic.backend ==
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN &&
ineligible_diagnostic.actual_backend ==
LARDON3D_RESOURCE_BACKEND_MIXED &&
ineligible_diagnostic.backend_fallback &&
ineligible_diagnostic.execution.local_ineligible_fallback_items > 0 &&
ineligible_diagnostic.execution.backend_failure_fallback_items == 0 &&
ineligible_diagnostic.execution.backend_other_fallback_items == 0 &&
strcmp(ineligible_diagnostic.backend_reason,
"vulkan-and-ineligible-pair-cpu-fallback") == 0);
CHECK(unsetenv("LARDON3D_TEST_MATCHER_INELIGIBLE_VULKAN_BEGIN_PAIR_ID") == 0 &&
unsetenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_BATCH") == 0 &&
lardon3d_task_queue_resume(fixture.state.task_queue,
local_ineligible_id) &&
wait_state(fixture.state.task_queue, local_ineligible_id,
TASK_COMPLETED, &snapshot) &&
lardon3d_task_queue_add(fixture.state.task_queue,
auto_after_ineligible_task, NULL) &&
wait_state(fixture.state.task_queue, auto_after_ineligible_id,
TASK_COMPLETED, &snapshot));
CHECK(lardon3d_resource_governor_internal_last_diagnostic(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &ineligible_diagnostic) &&
ineligible_diagnostic.backend ==
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN &&
ineligible_diagnostic.gpu_slots == 1);
/* Genuine begin failure is learned before publication. Even when that
* publication then fails, shared AUTO admission must already be disabled;
* the pre-created probe therefore selects its complete CPU capability. */
char backend_failure_pair[32];
char early_publication_pair[32];
CHECK(snprintf(backend_failure_pair, sizeof(backend_failure_pair), "%lu",
(unsigned long)fixture.pairs[1].candidate_pair_id) > 0 &&
snprintf(early_publication_pair, sizeof(early_publication_pair), "%lu",
(unsigned long)fixture.pairs[0].candidate_pair_id) > 0 &&
setenv("LARDON3D_TEST_MATCHER_FAIL_VULKAN_BEGIN_PAIR_ID",
backend_failure_pair, 1) == 0 &&
setenv("LARDON3D_TEST_MATCHER_FAIL_PUBLISH_PAIR_ID",
early_publication_pair, 1) == 0);
Lardon3DMatcherTaskConfiguration early_failure = settings;
early_failure.matcher.ratio_threshold = 0.685F;
uint64_t early_failure_id = 0;
Lardon3DTask *early_failure_task =
lardon3d_project_create_matcher_task_with_mode(
&fixture.state, &early_failure,
LARDON3D_MATCHER_TASK_MODE_ORB_VULKAN, &early_failure_id);
Lardon3DMatcherTaskConfiguration auto_after_failure = settings;
auto_after_failure.matcher.ratio_threshold = 0.684F;
uint64_t auto_after_failure_id = 0;
Lardon3DTask *auto_after_failure_task =
lardon3d_project_create_matcher_task(
&fixture.state, &auto_after_failure, &auto_after_failure_id);
size_t early_failure_results_before = 0;
size_t early_failure_results_after = 0;
CHECK(early_failure_task && auto_after_failure_task &&
count_results(&fixture, &early_failure_results_before) &&
lardon3d_task_queue_add(fixture.state.task_queue,
early_failure_task, NULL) &&
wait_state(fixture.state.task_queue, early_failure_id,
TASK_FAILED, &snapshot) &&
unsetenv("LARDON3D_TEST_MATCHER_FAIL_VULKAN_BEGIN_PAIR_ID") == 0 &&
unsetenv("LARDON3D_TEST_MATCHER_FAIL_PUBLISH_PAIR_ID") == 0 &&
count_results(&fixture, &early_failure_results_after) &&
early_failure_results_after == early_failure_results_before &&
no_staged_match_temporaries(&fixture) &&
lardon3d_task_queue_add(fixture.state.task_queue,
auto_after_failure_task, NULL) &&
wait_state(fixture.state.task_queue, auto_after_failure_id,
TASK_COMPLETED, &snapshot));
Lardon3DResourceSequenceDiagnostic after_failure_diagnostic;
CHECK(lardon3d_resource_governor_internal_last_diagnostic(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &after_failure_diagnostic) &&
after_failure_diagnostic.backend == LARDON3D_RESOURCE_BACKEND_CPU &&
after_failure_diagnostic.gpu_slots == 0 &&
lardon3d_resource_governor_internal_set_backend_available(
fixture.state.resource_governor,
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN, true));
/* Force only the private admission value, not the execution algorithm. The
* production rolling owner must submit two exact requests before finishing
* the oldest, then preserve ordered one-evidence publication and output
* cardinality without timing sleeps. */
CHECK(setenv("LARDON3D_TEST_MATCHER_INFLIGHT_LIMIT", "2", 1) == 0);
lardon3d_matcher_task_test_reset_backend_counters();
Lardon3DMatcherTaskConfiguration depth_two = settings;
depth_two.matcher.ratio_threshold = 0.683F;
uint64_t depth_two_id = 0;
size_t depth_two_before = 0;
size_t depth_two_after = 0;
CHECK(count_results(&fixture, &depth_two_before) &&
lardon3d_project_enqueue_matcher_task(
&fixture.state, &depth_two, &depth_two_id) &&
wait_state(fixture.state.task_queue, depth_two_id, TASK_COMPLETED,
&snapshot) &&
unsetenv("LARDON3D_TEST_MATCHER_INFLIGHT_LIMIT") == 0 &&
count_results(&fixture, &depth_two_after) &&
depth_two_after == depth_two_before + PERSISTED_PAIR_COUNT);
size_t depth_submit_first = 0;
size_t depth_submit_second = 0;
size_t depth_finish_first = 0;
size_t depth_publication_first = 0;
CHECK(find_test_event(TEST_EVENT_GPU_SUBMIT,
fixture.pairs[0].candidate_pair_id,
&depth_submit_first) &&
find_test_event(TEST_EVENT_GPU_SUBMIT,
fixture.pairs[1].candidate_pair_id,
&depth_submit_second) &&
find_test_event(TEST_EVENT_GPU_FINISH,
fixture.pairs[0].candidate_pair_id,
&depth_finish_first) &&
find_test_event(TEST_EVENT_PUBLICATION_START,
fixture.pairs[0].candidate_pair_id,
&depth_publication_first));
Lardon3DResourceSequenceDiagnostic depth_diagnostic;
CHECK(lardon3d_resource_governor_internal_last_diagnostic(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &depth_diagnostic) &&
depth_diagnostic.backend == LARDON3D_RESOURCE_BACKEND_ORB_VULKAN &&
depth_diagnostic.inflight_limit == 2 &&
depth_diagnostic.gpu_memory_bytes == 2 * 640 * 1024);
Lardon3DOrbVulkanInfo depth_backend_info;
CHECK(lardon3d_matcher_task_test_max_retained_vulkan_payload() ==
2 * 640 * 1024
&& lardon3d_orb_vulkan_backend_info(
fixture.state.orb_vulkan_backend, &depth_backend_info)
&& depth_backend_info.permanent_payload_bytes == 640 * 1024);
CHECK(depth_submit_first < depth_submit_second);
CHECK(depth_submit_second < depth_finish_first);
CHECK(depth_finish_first < depth_publication_first);
CHECK(wait_candidate_results_have_one_evidence(
database_path, fixture.pairs[0].candidate_pair_id));
lardon3d_matcher_task_test_reset_backend_counters();
Lardon3DMatcherTaskConfiguration gpu = settings;
gpu.matcher.ratio_threshold = 0.68F;
uint64_t gpu_id = 0;
size_t gpu_results_before = 0;
CHECK(count_results(&fixture, &gpu_results_before));
CHECK(lardon3d_project_enqueue_matcher_task_with_mode(
&fixture.state, &gpu, LARDON3D_MATCHER_TASK_MODE_ORB_VULKAN, &gpu_id));
CHECK(wait_state(fixture.state.task_queue, gpu_id, TASK_COMPLETED, &snapshot));
Lardon3DProjectDbTask gpu_durable;
CHECK(wait_durable_state(fixture.state.project_db, gpu_id, TASK_COMPLETED,
&gpu_durable));
CHECK(lardon3d_matcher_task_test_vulkan_uses() >= 1);
Lardon3DOrbVulkanInfo fixed_backend_info;
CHECK(lardon3d_matcher_task_test_max_retained_vulkan_payload() ==
640 * 1024
&& lardon3d_orb_vulkan_backend_info(
fixture.state.orb_vulkan_backend, &fixed_backend_info)
&& fixed_backend_info.permanent_payload_bytes == 640 * 1024);
size_t gpu_results_after = 0;
CHECK(count_results(&fixture, &gpu_results_after) &&
gpu_results_after == gpu_results_before + PERSISTED_PAIR_COUNT);
size_t submit_first = 0, finish_first = 0, submit_second = 0;
size_t publication_start = 0, publication_finish = 0;
CHECK(lardon3d_matcher_task_test_overlap_publications() >= 1 &&
find_test_event(TEST_EVENT_GPU_SUBMIT,
fixture.pairs[0].candidate_pair_id, &submit_first) &&
find_test_event(TEST_EVENT_GPU_FINISH,
fixture.pairs[0].candidate_pair_id, &finish_first) &&
find_test_event(TEST_EVENT_GPU_SUBMIT,
fixture.pairs[1].candidate_pair_id, &submit_second) &&
find_test_event(TEST_EVENT_PUBLICATION_START,
fixture.pairs[0].candidate_pair_id,
&publication_start) &&
find_test_event(TEST_EVENT_PUBLICATION_FINISH,
fixture.pairs[0].candidate_pair_id,
&publication_finish));
CHECK(submit_first < finish_first && finish_first < submit_second &&
submit_second < publication_start &&
publication_start < publication_finish);
CHECK(candidate_results_have_one_evidence(
database_path, fixture.pairs[0].candidate_pair_id));
/* A rejected successor begin has no GPU event or partial evidence; that
* pair runs wholly on CPU and every exact backend slot remains reusable. */
char failed_begin_pair[32];
CHECK(snprintf(failed_begin_pair, sizeof(failed_begin_pair), "%lu",
(unsigned long)fixture.pairs[1].candidate_pair_id) > 0 &&
setenv("LARDON3D_TEST_MATCHER_FAIL_VULKAN_BEGIN_PAIR_ID",
failed_begin_pair, 1) == 0);
lardon3d_matcher_task_test_reset_backend_counters();
Lardon3DMatcherTaskConfiguration begin_fallback = settings;
begin_fallback.matcher.ratio_threshold = 0.665F;
uint64_t begin_fallback_id = 0;
CHECK(count_results(&fixture, &gpu_results_before) &&
lardon3d_project_enqueue_matcher_task_with_mode(
&fixture.state, &begin_fallback,
LARDON3D_MATCHER_TASK_MODE_ORB_VULKAN, &begin_fallback_id) &&
wait_state(fixture.state.task_queue, begin_fallback_id,
TASK_COMPLETED, &snapshot) &&
unsetenv("LARDON3D_TEST_MATCHER_FAIL_VULKAN_BEGIN_PAIR_ID") == 0 &&
count_results(&fixture, &gpu_results_after) &&
gpu_results_after == gpu_results_before + PERSISTED_PAIR_COUNT);
CHECK(!find_test_event(TEST_EVENT_GPU_SUBMIT,
fixture.pairs[1].candidate_pair_id, &submit_second));
CHECK(lardon3d_matcher_task_test_overlap_publications() == 0);
/* Publication failure occurs after successor submission. Failure cleanup
* must discard that private request so a following Task can reuse the slot. */
char failed_publish_pair[32];
CHECK(snprintf(failed_publish_pair, sizeof(failed_publish_pair), "%lu",
(unsigned long)fixture.pairs[0].candidate_pair_id) > 0 &&
setenv("LARDON3D_TEST_MATCHER_FAIL_PUBLISH_PAIR_ID",
failed_publish_pair, 1) == 0 &&
setenv("LARDON3D_TEST_MATCHER_INFLIGHT_LIMIT", "2", 1) == 0);
lardon3d_matcher_task_test_reset_backend_counters();
Lardon3DMatcherTaskConfiguration failed_publication = settings;
failed_publication.matcher.ratio_threshold = 0.655F;
uint64_t failed_publication_id = 0;
CHECK(count_results(&fixture, &gpu_results_before));
CHECK(lardon3d_project_enqueue_matcher_task(
&fixture.state, &failed_publication, &failed_publication_id));
CHECK(wait_state(fixture.state.task_queue, failed_publication_id,
TASK_FAILED, &snapshot));
CHECK(unsetenv("LARDON3D_TEST_MATCHER_FAIL_PUBLISH_PAIR_ID") == 0);
CHECK(unsetenv("LARDON3D_TEST_MATCHER_INFLIGHT_LIMIT") == 0);
CHECK(count_results(&fixture, &gpu_results_after));
CHECK(gpu_results_after == gpu_results_before);
CHECK(lardon3d_matcher_task_test_overlap_publications() == 1);
CHECK(no_staged_match_temporaries(&fixture));
lardon3d_matcher_task_test_reset_backend_counters();
Lardon3DMatcherTaskConfiguration after_publish_failure = settings;
after_publish_failure.matcher.ratio_threshold = 0.645F;
uint64_t after_publish_failure_id = 0;
CHECK(lardon3d_project_enqueue_matcher_task_with_mode(
&fixture.state, &after_publish_failure,
LARDON3D_MATCHER_TASK_MODE_ORB_VULKAN,
&after_publish_failure_id) &&
wait_state(fixture.state.task_queue, after_publish_failure_id,
TASK_COMPLETED, &snapshot) &&
lardon3d_matcher_task_test_vulkan_uses() >= 2);
/* At depth two, local ineligibility of the oldest pair consumes no slot, so
* the successor is already pending when its whole-pair CPU fallback fails.
* The Task owner must discard that successor before sequence cleanup can
* shrink the mapped payload and release the Governor reservation. */
char failed_cpu_fallback_pair[32];
CHECK(snprintf(failed_cpu_fallback_pair,
sizeof(failed_cpu_fallback_pair), "%lu",
(unsigned long)fixture.pairs[0].candidate_pair_id) > 0);
Lardon3DOrbVulkanTelemetry cleanup_before = {0};
Lardon3DOrbVulkanTelemetry cleanup_after = {0};
CHECK(lardon3d_orb_vulkan_internal_telemetry(
fixture.state.orb_vulkan_backend, &cleanup_before) &&
setenv("LARDON3D_TEST_MATCHER_INELIGIBLE_VULKAN_BEGIN_PAIR_ID",
failed_cpu_fallback_pair, 1) == 0 &&
setenv("LARDON3D_TEST_MATCHER_FAIL_COMPUTE_PAIR_ID",
failed_cpu_fallback_pair, 1) == 0 &&
setenv("LARDON3D_TEST_MATCHER_INFLIGHT_LIMIT", "2", 1) == 0);
lardon3d_matcher_task_test_reset_backend_counters();
Lardon3DMatcherTaskConfiguration failed_cpu_fallback = settings;
failed_cpu_fallback.matcher.ratio_threshold = 0.643F;
uint64_t failed_cpu_fallback_id = 0;
size_t failed_cpu_fallback_before = 0;
size_t failed_cpu_fallback_after = 0;
CHECK(count_results(&fixture, &failed_cpu_fallback_before) &&
lardon3d_project_enqueue_matcher_task(
&fixture.state, &failed_cpu_fallback,
&failed_cpu_fallback_id) &&
wait_state(fixture.state.task_queue, failed_cpu_fallback_id,
TASK_FAILED, &snapshot) &&
unsetenv(
"LARDON3D_TEST_MATCHER_INELIGIBLE_VULKAN_BEGIN_PAIR_ID") == 0 &&
unsetenv("LARDON3D_TEST_MATCHER_FAIL_COMPUTE_PAIR_ID") == 0 &&
unsetenv("LARDON3D_TEST_MATCHER_INFLIGHT_LIMIT") == 0 &&
count_results(&fixture, &failed_cpu_fallback_after) &&
failed_cpu_fallback_after == failed_cpu_fallback_before &&
no_staged_match_temporaries(&fixture));
size_t failed_cpu_successor_submit = 0;
Lardon3DOrbVulkanInfo cleaned_backend_info = {0};
CHECK(find_test_event(TEST_EVENT_GPU_SUBMIT,
fixture.pairs[1].candidate_pair_id,
&failed_cpu_successor_submit) &&
lardon3d_matcher_task_test_max_retained_vulkan_payload() ==
2 * 640 * 1024 &&
lardon3d_orb_vulkan_internal_telemetry(
fixture.state.orb_vulkan_backend, &cleanup_after) &&
cleanup_after.discards == cleanup_before.discards + 1 &&
cleanup_after.pending_slots == 0 &&
!cleanup_after.slot_pending &&
cleanup_after.retained_capacity == 1 &&
cleanup_after.retained_payload_bytes == 640 * 1024 &&
!cleanup_after.sequence_capacity_active &&
lardon3d_orb_vulkan_backend_info(
fixture.state.orb_vulkan_backend, &cleaned_backend_info) &&
cleaned_backend_info.available &&
cleaned_backend_info.permanent_payload_bytes == 640 * 1024);
lardon3d_matcher_task_test_reset_backend_counters();
Lardon3DMatcherTaskConfiguration after_cpu_fallback_failure = settings;
after_cpu_fallback_failure.matcher.ratio_threshold = 0.642F;
uint64_t after_cpu_fallback_failure_id = 0;
CHECK(lardon3d_project_enqueue_matcher_task_with_mode(
&fixture.state, &after_cpu_fallback_failure,
LARDON3D_MATCHER_TASK_MODE_ORB_VULKAN,
&after_cpu_fallback_failure_id) &&
wait_state(fixture.state.task_queue,
after_cpu_fallback_failure_id, TASK_COMPLETED, &snapshot) &&
lardon3d_matcher_task_test_vulkan_uses() >= 2 &&
count_results(&fixture, &gpu_results_after) &&
gpu_results_after ==
failed_cpu_fallback_before + PERSISTED_PAIR_COUNT &&
wait_candidate_results_have_one_evidence(
database_path, fixture.pairs[0].candidate_pair_id) &&
lardon3d_orb_vulkan_internal_telemetry(
fixture.state.orb_vulkan_backend, &cleanup_after) &&
cleanup_after.pending_slots == 0 &&
cleanup_after.retained_capacity == 1 &&
!cleanup_after.sequence_capacity_active);
/* Cancellation while predecessor publication is paused owns a submitted
* successor. The sequence-exit path discards it, and reuse is immediate. */
CHECK(setenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_PUBLICATION", "1", 1) == 0);
lardon3d_matcher_task_test_reset_backend_counters();
Lardon3DMatcherTaskConfiguration cancelled_gpu = settings;
cancelled_gpu.matcher.ratio_threshold = 0.635F;
uint64_t cancelled_gpu_id = 0;
CHECK(lardon3d_project_enqueue_matcher_task_with_mode(
&fixture.state, &cancelled_gpu,
LARDON3D_MATCHER_TASK_MODE_ORB_VULKAN, &cancelled_gpu_id) &&
wait_state(fixture.state.task_queue, cancelled_gpu_id, TASK_PAUSED,
&snapshot) &&
lardon3d_task_queue_cancel(fixture.state.task_queue,
cancelled_gpu_id) &&
wait_state(fixture.state.task_queue, cancelled_gpu_id,
TASK_CANCELLED, &snapshot) &&
unsetenv("LARDON3D_TEST_MATCHER_PAUSE_AFTER_PUBLICATION") == 0 &&
lardon3d_matcher_task_test_overlap_publications() == 1 &&
no_staged_match_temporaries(&fixture));
lardon3d_matcher_task_test_reset_backend_counters();
Lardon3DMatcherTaskConfiguration after_cancel = settings;
after_cancel.matcher.ratio_threshold = 0.625F;
uint64_t after_cancel_id = 0;
CHECK(lardon3d_project_enqueue_matcher_task_with_mode(
&fixture.state, &after_cancel,
LARDON3D_MATCHER_TASK_MODE_ORB_VULKAN, &after_cancel_id) &&
wait_state(fixture.state.task_queue, after_cancel_id, TASK_COMPLETED,
&snapshot) &&
lardon3d_matcher_task_test_vulkan_uses() >= 2);
/* Runtime backend failure after valid GPU admission falls back through the
* exact CPU implementation; it never changes the immutable estimate or the
* scientific Match identity. */
CHECK(setenv("LARDON3D_TEST_MATCHER_FORCE_FALLBACK", "1", 1) == 0);
lardon3d_matcher_task_test_reset_backend_counters();
Lardon3DMatcherTaskConfiguration fallback = settings;
fallback.matcher.ratio_threshold = 0.67F;
uint64_t fallback_id = 0;
CHECK(lardon3d_project_enqueue_matcher_task_with_mode(
&fixture.state, &fallback, LARDON3D_MATCHER_TASK_MODE_ORB_VULKAN,
&fallback_id));
CHECK(wait_state(fixture.state.task_queue, fallback_id, TASK_COMPLETED,
&snapshot));
Lardon3DProjectDbTask fallback_durable;
CHECK(wait_durable_state(fixture.state.project_db, fallback_id,
TASK_COMPLETED, &fallback_durable));
CHECK(lardon3d_matcher_task_test_forced_fallbacks() >= 1);
CHECK(lardon3d_matcher_task_test_vulkan_uses() == 0);
Lardon3DResourceSequenceDiagnostic fallback_diagnostic;
CHECK(lardon3d_resource_governor_internal_last_diagnostic(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &fallback_diagnostic) &&
fallback_diagnostic.backend ==
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN &&
fallback_diagnostic.actual_backend == LARDON3D_RESOURCE_BACKEND_CPU &&
fallback_diagnostic.backend_fallback &&
fallback_diagnostic.helper_limit == 0 &&
strcmp(fallback_diagnostic.backend_reason,
"vulkan-failed-whole-pair-cpu-fallback") == 0);
CHECK(unsetenv("LARDON3D_TEST_MATCHER_FORCE_FALLBACK") == 0);
CHECK(candidate_results_have_one_evidence(
database_path, fixture.pairs[0].candidate_pair_id));
#else
/* The supported Vulkan-disabled build exposes no backend. An explicit GPU
* request must fail before Task-ID allocation instead of becoming CPU work. */
Lardon3DMatcherTaskConfiguration gpu = settings;
gpu.matcher.ratio_threshold = 0.68F;
uint64_t gpu_id = 99;
CHECK(lardon3d_project_enqueue_matcher_task_with_mode(
&fixture.state, &gpu, LARDON3D_MATCHER_TASK_MODE_ORB_VULKAN,
&gpu_id) == false &&
gpu_id == 0);
#endif
/* The request remains eight, but only two CPUs are available after host
* headroom. Successful completion exercises the reduced Governor contract. */
Lardon3DResourcePolicy reduced_policy = interactive_policy();
reduced_policy.system_cpu_reserve = 14;
CHECK(lardon3d_resource_governor_set_policy(fixture.state.resource_governor,
&reduced_policy));
Lardon3DMatcherTaskConfiguration reduced = settings;
reduced.matcher.ratio_threshold = 0.83F;
uint64_t reduced_id = 0;
CHECK(lardon3d_project_enqueue_matcher_task_with_mode(
&fixture.state, &reduced, LARDON3D_MATCHER_TASK_MODE_CPU_PARALLEL,
&reduced_id));
CHECK(wait_state(fixture.state.task_queue, reduced_id, TASK_COMPLETED,
&snapshot));
Lardon3DResourcePolicy restored_policy = interactive_policy();
CHECK(lardon3d_resource_governor_set_policy(fixture.state.resource_governor,
&restored_policy));
/* A failed computation seals the ordered suffix. The finished checkpoint
* may retain only the already durable contiguous prefix. */
Lardon3DMatcherTaskConfiguration fail_first = settings;
fail_first.matcher.ratio_threshold = 0.70F;
CHECK(run_failed_at_pair(&fixture, fail_first,
"LARDON3D_TEST_MATCHER_FAIL_COMPUTE_PAIR_ID",
fixture.pairs[0].candidate_pair_id, 0, 0));
Lardon3DMatcherTaskConfiguration fail_middle = settings;
fail_middle.matcher.ratio_threshold = 0.71F;
CHECK(run_failed_at_pair(&fixture, fail_middle,
"LARDON3D_TEST_MATCHER_FAIL_COMPUTE_PAIR_ID",
fixture.pairs[5].candidate_pair_id, 4,
fixture.pairs[4].candidate_pair_id));
Lardon3DMatcherTaskConfiguration fail_last = settings;
fail_last.matcher.ratio_threshold = 0.72F;
CHECK(run_failed_at_pair(&fixture, fail_last,
"LARDON3D_TEST_MATCHER_FAIL_COMPUTE_PAIR_ID",
fixture.pairs[PAIR_COUNT - 1].candidate_pair_id,
PERSISTED_PAIR_COUNT - 1,
fixture.pairs[PAIR_COUNT - 2].candidate_pair_id));
Lardon3DMatcherTaskConfiguration publish_first = settings;
publish_first.matcher.ratio_threshold = 0.73F;
CHECK(run_failed_at_pair(&fixture, publish_first,
"LARDON3D_TEST_MATCHER_FAIL_PUBLISH_PAIR_ID",
fixture.pairs[0].candidate_pair_id, 0, 0));
Lardon3DMatcherTaskConfiguration publish_middle = settings;
publish_middle.matcher.ratio_threshold = 0.74F;
CHECK(run_failed_at_pair(&fixture, publish_middle,
"LARDON3D_TEST_MATCHER_FAIL_PUBLISH_PAIR_ID",
fixture.pairs[5].candidate_pair_id, 4,
fixture.pairs[4].candidate_pair_id));
Lardon3DMatcherTaskConfiguration publish_last = settings;
publish_last.matcher.ratio_threshold = 0.76F;
CHECK(run_failed_at_pair(&fixture, publish_last,
"LARDON3D_TEST_MATCHER_FAIL_PUBLISH_PAIR_ID",
fixture.pairs[PAIR_COUNT - 1].candidate_pair_id,
PERSISTED_PAIR_COUNT - 1,
fixture.pairs[PAIR_COUNT - 2].candidate_pair_id));
uint64_t estimate_task_id = 0;
Lardon3DTask *estimate_task = lardon3d_project_create_matcher_task(
&fixture.state, &settings, &estimate_task_id);
Lardon3DTaskDurableSnapshot estimate_snapshot;
CHECK(estimate_task != NULL && estimate_task_id != 0);
CHECK(lardon3d_task_durable_snapshot(estimate_task, &estimate_snapshot));
/* AUTO backend choice is private runtime state. MIXED truthfully records
* that the operation may consume CPU or Vulkan without persisting either
* backend choice. Explicit CPU retains the exact CPU-class signature. */
CHECK(estimate_snapshot.estimate.desired_cpu_threads > 1);
CHECK(estimate_snapshot.estimate.gpu_memory_fixed_bytes == 0);
CHECK(estimate_snapshot.estimate.desired_gpu_slots == 0);
CHECK(estimate_snapshot.estimate.task_class ==
LARDON3D_RESOURCE_TASK_MIXED);
Lardon3DTaskDurableSnapshot current_auto = estimate_snapshot;
Lardon3DTaskDurableSnapshot current_cpu = current_auto;
current_cpu.estimate.task_class = LARDON3D_RESOURCE_TASK_CPU;
Lardon3DTaskDurableSnapshot current_gpu = current_cpu;
current_gpu.estimate.gpu_memory_fixed_bytes =
LARDON3D_ORB_VULKAN_PERMANENT_BUFFER_BYTES;
current_gpu.estimate.desired_cpu_threads = 1;
current_gpu.estimate.desired_gpu_slots = 1;
lardon3d_task_destroy(estimate_task);
estimate_task = NULL;
uint64_t explicit_cpu_id = 0;
Lardon3DTask *explicit_cpu_task =
lardon3d_project_create_matcher_task_with_mode(
&fixture.state, &settings, LARDON3D_MATCHER_TASK_MODE_CPU_PARALLEL,
&explicit_cpu_id);
Lardon3DTaskDurableSnapshot explicit_cpu_snapshot;
CHECK(explicit_cpu_task && explicit_cpu_id != current_auto.id &&
lardon3d_task_durable_snapshot(explicit_cpu_task,
&explicit_cpu_snapshot));
CHECK(same_estimate(&explicit_cpu_snapshot.estimate,
&current_cpu.estimate));
current_cpu = explicit_cpu_snapshot;
current_gpu = current_cpu;
current_gpu.estimate.gpu_memory_fixed_bytes =
LARDON3D_ORB_VULKAN_PERMANENT_BUFFER_BYTES;
current_gpu.estimate.desired_cpu_threads = 1;
current_gpu.estimate.desired_gpu_slots = 1;
lardon3d_task_destroy(explicit_cpu_task);
#ifdef LARDON3D_MATCHER_TASK_VULKAN
estimate_task = lardon3d_project_create_matcher_task_with_mode(
&fixture.state, &settings, LARDON3D_MATCHER_TASK_MODE_ORB_VULKAN,
&estimate_task_id);
CHECK(estimate_task != NULL &&
lardon3d_task_durable_snapshot(estimate_task, &estimate_snapshot));
CHECK(same_estimate(&estimate_snapshot.estimate, &current_gpu.estimate));
current_gpu = estimate_snapshot;
#endif
/* Explicit selection failures occur before Task-ID allocation and cannot
* silently become CPU work. Normal create remains AUTO. */
Lardon3DMatcherTaskConfiguration wrong_kind = settings;
wrong_kind.matcher.kind = LARDON3D_MATCHER_SIFT_BF;
(void)snprintf(wrong_kind.feature_extractor_kind,
sizeof(wrong_kind.feature_extractor_kind), "sift");
uint64_t rejected_id = 99;
CHECK(lardon3d_project_create_matcher_task_with_mode(
&fixture.state, &wrong_kind,
LARDON3D_MATCHER_TASK_MODE_ORB_VULKAN, &rejected_id) == NULL &&
rejected_id == 0);
rejected_id = 99;
CHECK(lardon3d_project_create_matcher_task_with_mode(
&fixture.state, &settings, (Lardon3DMatcherTaskMode)99,
&rejected_id) == NULL &&
rejected_id == 0);
bool gpu_available = fixture.state.hardware_profile.gpu_available;
fixture.state.hardware_profile.gpu_available = false;
rejected_id = 99;
CHECK(lardon3d_project_create_matcher_task_with_mode(
&fixture.state, &settings,
LARDON3D_MATCHER_TASK_MODE_ORB_VULKAN, &rejected_id) == NULL &&
rejected_id == 0);
lardon3d_matcher_task_test_reset_backend_counters();
Lardon3DMatcherTaskConfiguration no_gpu_auto = settings;
no_gpu_auto.matcher.ratio_threshold = 0.63F;
uint64_t no_gpu_id = 0;
CHECK(lardon3d_project_enqueue_matcher_task(
&fixture.state, &no_gpu_auto, &no_gpu_id));
CHECK(wait_state(fixture.state.task_queue, no_gpu_id, TASK_COMPLETED,
&snapshot));
CHECK(lardon3d_matcher_task_test_vulkan_uses() == 0);
Lardon3DResourceSequenceDiagnostic cpu_diagnostic;
CHECK(lardon3d_resource_governor_internal_last_diagnostic(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &cpu_diagnostic));
CHECK(cpu_diagnostic.backend == LARDON3D_RESOURCE_BACKEND_CPU &&
cpu_diagnostic.gpu_slots == 0);
fixture.state.hardware_profile.gpu_available = gpu_available;
Lardon3DOrbVulkanBackend *backend = fixture.state.orb_vulkan_backend;
fixture.state.orb_vulkan_backend = NULL;
rejected_id = 99;
CHECK(lardon3d_project_create_matcher_task_with_mode(
&fixture.state, &settings,
LARDON3D_MATCHER_TASK_MODE_ORB_VULKAN, &rejected_id) == NULL &&
rejected_id == 0);
fixture.state.orb_vulkan_backend = backend;
/* Reconstruction accepts exact current CPU12 forms plus the preceding
* CPU8-per-pair and oldest fixed-memory CPU12 forms. All historic resource
* policies normalize only in memory; neighboring shapes stay corruption. */
Lardon3DTaskReconstructionContext reconstruction = {
.project_path = fixture.state.project_path,
.project_db = fixture.state.project_db,
.resource_governor = fixture.state.resource_governor,
.orb_vulkan_backend = fixture.state.orb_vulkan_backend,
};
/* Restart preserves the two normal/override policies without a schema or
* codec field. On a Vulkan build the restored AUTO signature selects GPU,
* while the restored explicit CPU signature remains fixed CPU. */
Lardon3DTask *restarted_auto = NULL;
CHECK(lardon3d_task_kind_registry_restore(
lardon3d_task_kind_registry_production(),
LARDON3D_MATCHER_TASK_KIND, LARDON3D_MATCHER_TASK_KIND_VERSION,
&current_auto, &reconstruction, &restarted_auto) ==
LARDON3D_TASK_KIND_OK &&
restarted_auto);
Lardon3DTaskDurableSnapshot order_historical_cpu = current_cpu;
order_historical_cpu.estimate.memory_fixed_bytes = 10U * 1024U * 1024U;
order_historical_cpu.estimate.memory_bytes_per_item = 0;
order_historical_cpu.estimate.desired_cpu_threads = 12;
order_historical_cpu.estimate.maximum_batch_size = 8;
Lardon3DTaskDurableSnapshot order_historical_gpu = current_gpu;
order_historical_gpu.estimate.memory_fixed_bytes = 10U * 1024U * 1024U;
order_historical_gpu.estimate.memory_bytes_per_item = 0;
order_historical_gpu.estimate.desired_cpu_threads = 12;
order_historical_gpu.estimate.maximum_batch_size = 8;
const Lardon3DTaskDurableSnapshot *fixed_restore_order[] = {
&current_cpu,
&current_gpu,
&order_historical_cpu,
&order_historical_gpu,
};
/* AUTO establishes shared eligibility. Later co-restoration of fixed CPU,
* fixed Vulkan, and historical forms is order-independent and must not
* clear it before the already-restored AUTO Task reaches admission. */
for (size_t index = 0;
index < sizeof(fixed_restore_order) / sizeof(fixed_restore_order[0]);
++index) {
Lardon3DTask *fixed_restored = NULL;
CHECK(lardon3d_task_kind_registry_restore(
lardon3d_task_kind_registry_production(),
LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, fixed_restore_order[index],
&reconstruction, &fixed_restored) == LARDON3D_TASK_KIND_OK &&
fixed_restored);
lardon3d_task_destroy(fixed_restored);
}
CHECK(lardon3d_task_queue_add(fixture.state.task_queue, restarted_auto, NULL));
CHECK(wait_state(fixture.state.task_queue, current_auto.id, TASK_COMPLETED,
&snapshot));
Lardon3DResourceSequenceDiagnostic restart_diagnostic;
CHECK(lardon3d_resource_governor_internal_last_diagnostic(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &restart_diagnostic));
#ifdef LARDON3D_MATCHER_TASK_VULKAN
CHECK(restart_diagnostic.backend ==
LARDON3D_RESOURCE_BACKEND_ORB_VULKAN &&
restart_diagnostic.gpu_slots == 1);
#else
CHECK(restart_diagnostic.backend == LARDON3D_RESOURCE_BACKEND_CPU &&
restart_diagnostic.gpu_slots == 0);
#endif
Lardon3DTask *restarted_cpu = NULL;
CHECK(lardon3d_task_kind_registry_restore(
lardon3d_task_kind_registry_production(),
LARDON3D_MATCHER_TASK_KIND, LARDON3D_MATCHER_TASK_KIND_VERSION,
&current_cpu, &reconstruction, &restarted_cpu) ==
LARDON3D_TASK_KIND_OK &&
restarted_cpu);
CHECK(lardon3d_task_queue_add(fixture.state.task_queue, restarted_cpu, NULL));
CHECK(wait_state(fixture.state.task_queue, current_cpu.id, TASK_COMPLETED,
&snapshot));
CHECK(lardon3d_resource_governor_internal_last_diagnostic(
fixture.state.resource_governor, LARDON3D_MATCHER_TASK_KIND,
LARDON3D_MATCHER_TASK_KIND_VERSION, &restart_diagnostic));
CHECK(restart_diagnostic.backend == LARDON3D_RESOURCE_BACKEND_CPU &&
restart_diagnostic.gpu_slots == 0);
Lardon3DTaskDurableSnapshot historical_cpu = order_historical_cpu;
Lardon3DTaskDurableSnapshot historical_gpu = order_historical_gpu;
Lardon3DTaskDurableSnapshot previous_cpu = current_cpu;
previous_cpu.estimate.maximum_batch_size = 8;
previous_cpu.estimate.desired_cpu_threads = 8;
Lardon3DTaskDurableSnapshot previous_gpu = current_gpu;
previous_gpu.estimate.maximum_batch_size = 8;
char reconciled_path[PATH_MAX];
CHECK(snprintf(reconciled_path, sizeof(reconciled_path),
"%s/.lardon3d/checkpoints/%lu.chk",
fixture.state.project_path,
(unsigned long)estimate_task_id) > 0 &&
lardon3d_task_checkpoint_save(reconciled_path, &historical_gpu) ==
LARDON3D_TASK_CHECKPOINT_OK);
const Lardon3DTaskDurableSnapshot *accepted[] = {
&current_auto, &current_cpu, &current_gpu, &previous_cpu, &previous_gpu,
&historical_cpu, &historical_gpu};
for (size_t index = 0; index < sizeof(accepted) / sizeof(accepted[0]); ++index) {
Lardon3DTask *restored = NULL;
CHECK(lardon3d_task_kind_registry_restore(
lardon3d_task_kind_registry_production(),
LARDON3D_MATCHER_TASK_KIND, LARDON3D_MATCHER_TASK_KIND_VERSION,
accepted[index], &reconstruction, &restored) ==
LARDON3D_TASK_KIND_OK &&
restored);
Lardon3DResourceEstimate restored_estimate;
CHECK(lardon3d_task_resource_estimate(restored, &restored_estimate));
const Lardon3DResourceEstimate *expected =
index == 3 || index == 5 ? &current_cpu.estimate
: index == 4 || index == 6 ? &current_gpu.estimate
: &accepted[index]->estimate;
CHECK(same_estimate(&restored_estimate, expected));
lardon3d_task_destroy(restored);
}
Lardon3DTaskDurableSnapshot reconciled_snapshot;
uint32_t reconciled_version = 0;
CHECK(lardon3d_task_checkpoint_load(reconciled_path, &reconciled_snapshot,
&reconciled_version) ==
LARDON3D_TASK_CHECKPOINT_OK &&
reconciled_version == LARDON3D_TASK_CHECKPOINT_VERSION &&
same_estimate(&reconciled_snapshot.estimate, &historical_gpu.estimate));
char staged_path[PATH_MAX];
CHECK(snprintf(staged_path, sizeof(staged_path), "%s.next",
reconciled_path) > 0 &&
access(staged_path, F_OK) != 0 && errno == ENOENT);
Lardon3DTaskDurableSnapshot malformed[5] = {
historical_cpu, historical_cpu, historical_gpu, historical_gpu,
current_gpu};
malformed[0].estimate.memory_fixed_bytes--;
malformed[1].estimate.memory_bytes_per_item = 1;
malformed[2].estimate.gpu_memory_fixed_bytes++;
malformed[3].estimate.desired_cpu_threads = 11;
/* MIXED is truthful only for the CPU-shaped durable AUTO policy. A Vulkan
* resource shape cannot use the class as a synthetic backend tag. */
malformed[4].estimate.task_class = LARDON3D_RESOURCE_TASK_MIXED;
for (size_t index = 0; index < sizeof(malformed) / sizeof(malformed[0]); ++index) {
Lardon3DTask *restored = NULL;
CHECK(lardon3d_task_kind_registry_restore(
lardon3d_task_kind_registry_production(),
LARDON3D_MATCHER_TASK_KIND, LARDON3D_MATCHER_TASK_KIND_VERSION,
&malformed[index], &reconstruction, &restored) ==
LARDON3D_TASK_KIND_RECONSTRUCTION_FAILED &&
restored == NULL);
}
lardon3d_task_destroy(estimate_task);
stop_runtime(&fixture);
CHECK(remove_tree(fixture.root));
#if defined(LARDON3D_MATCHER_TASK_VULKAN) && \
defined(LARDON3D_MATCHER_TASK_BENCHMARK_PIPELINE)
/* Distinct fresh Projects prevent identity reuse from hiding either control.
* Runner-private tokens fix one normal Governor-admitted Vulkan capability
* for the depth and batch matrices. Synchronous remains the historical
* depth-one/batch-two fence baseline; all scientific fields stay exact. */
PipelineEvidence rolling_one = {0};
PipelineEvidence rolling_two = {0};
PipelineEvidence batch_four = {0};
PipelineEvidence batch_eight = {0};
PipelineEvidence batch_twelve = {0};
PipelineEvidence synchronous = {0};
CHECK(capture_pipeline_evidence(false, 1, 2, &rolling_one));
CHECK(capture_pipeline_evidence(false, 2, 2, &rolling_two));
CHECK(capture_pipeline_evidence(false, 1, 4, &batch_four));
CHECK(capture_pipeline_evidence(false, 1, 8, &batch_eight));
CHECK(capture_pipeline_evidence(false, 1, 12, &batch_twelve));
CHECK(capture_pipeline_evidence(true, 1, 0, &synchronous));
CHECK(rolling_one.overlap_publications >= 1);
CHECK(rolling_two.overlap_publications >= 1);
CHECK(batch_four.overlap_publications >= 1);
CHECK(batch_eight.overlap_publications >= 1);
CHECK(batch_twelve.overlap_publications >= 1);
CHECK(synchronous.overlap_publications == 0);
CHECK(same_forced_contract_except_depth(&rolling_one, &rolling_two));
CHECK(same_forced_contract_except_batch(&rolling_one, &batch_four, 4));
CHECK(same_forced_contract_except_batch(&rolling_one, &batch_eight, 8));
CHECK(same_forced_contract_except_batch(&rolling_one, &batch_twelve, 12));
/* Sequence grouping is deliberately different at each fixed batch. The
* production Matcher-owned item comparator must nevertheless count the same
* 29 locally ineligible pairs exactly once in every cohort. */
CHECK(rolling_one.aggregate.local_ineligible_fallback_items ==
PERSISTED_PAIR_COUNT - PIPELINE_ELIGIBLE_PAIR_COUNT);
CHECK(rolling_two.aggregate.local_ineligible_fallback_items ==
rolling_one.aggregate.local_ineligible_fallback_items);
CHECK(batch_four.aggregate.local_ineligible_fallback_items ==
rolling_one.aggregate.local_ineligible_fallback_items);
CHECK(batch_eight.aggregate.local_ineligible_fallback_items ==
rolling_one.aggregate.local_ineligible_fallback_items);
CHECK(batch_twelve.aggregate.local_ineligible_fallback_items ==
rolling_one.aggregate.local_ineligible_fallback_items);
CHECK(synchronous.aggregate.local_ineligible_fallback_items ==
rolling_one.aggregate.local_ineligible_fallback_items);
CHECK(rolling_one.aggregate.backend_ineligible_fallback_sequences !=
batch_four.aggregate.backend_ineligible_fallback_sequences);
CHECK(batch_four.aggregate.backend_ineligible_fallback_sequences !=
batch_eight.aggregate.backend_ineligible_fallback_sequences);
CHECK(same_pipeline_scientific_output(&rolling_one, &rolling_two));
CHECK(same_pipeline_scientific_output(&rolling_one, &batch_four));
CHECK(same_pipeline_scientific_output(&rolling_one, &batch_eight));
CHECK(same_pipeline_scientific_output(&rolling_one, &batch_twelve));
CHECK(same_pipeline_scientific_output(&rolling_two, &synchronous));
CHECK(forced_benchmark_fail_closed());
CHECK(pair_local_neighbor_failure_case(
"LARDON3D_TEST_MATCHER_FAIL_VULKAN_BEGIN_PAIR_ID"));
CHECK(pair_local_neighbor_failure_case(
"LARDON3D_TEST_MATCHER_FAIL_VULKAN_FINISH_PAIR_ID"));
CHECK(local_vulkan_failure_preserves_backend_case(
"LARDON3D_TEST_MATCHER_FAIL_LOCAL_VULKAN_BEGIN_PAIR_ID", true));
CHECK(local_vulkan_failure_preserves_backend_case(
"LARDON3D_TEST_MATCHER_FAIL_LOCAL_VULKAN_FINISH_PAIR_ID", false));
CHECK(durable_fallback_prefix_case(false, PREFIX_EXIT_CANCEL));
CHECK(durable_fallback_prefix_case(
false, PREFIX_EXIT_COMPUTE_FAILURE));
CHECK(durable_fallback_prefix_case(
false, PREFIX_EXIT_PUBLICATION_FAILURE));
CHECK(durable_fallback_prefix_case(true, PREFIX_EXIT_CANCEL));
CHECK(durable_fallback_prefix_case(
true, PREFIX_EXIT_COMPUTE_FAILURE));
CHECK(durable_fallback_prefix_case(
true, PREFIX_EXIT_PUBLICATION_FAILURE));
#endif
return true;
}
int main(void) {
Lardon3DResourceDriverPolicyResult driver_policy =
lardon3d_resource_governor_internal_configure_driver_policy();
return driver_policy != LARDON3D_RESOURCE_DRIVER_POLICY_FAILED &&
driver_policy !=
LARDON3D_RESOURCE_DRIVER_POLICY_REJECTED_UNSAFE &&
run_test()
? EXIT_SUCCESS
: EXIT_FAILURE;
}
Reference in a new issue View git blame Copy permalink