lei.chen/myxce
1
0
Fork 1
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat(libxce-alloc-preason-equality): white-box equivalence tests use public job_alloc_eq/job_preason_eq (task 4.1)

Browse source 
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Rongsong Shen 2026-09-28 10:27:46 +00:00
parent c1960457f8
commit 6110d12e5a
Signed by untrusted user: rshen
GPG key ID: 80533536B0EB651C
4 changed files with 217 additions and 46 deletions
Download patch file Download diff file Expand all files Collapse all files

95
src/scheduler/testsuite/test_sim_equivalence.c
View file

@ -114,17 +114,22 @@
* pass even if event translation or picker-state-rebuild silently dropped
* every field the ordering logic itself does not read.
*
* Comparator design: reuses sim_verify.c's own leaf-level structural
* comparators, sim_verify_job_alloc_eq()/sim_verify_job_preason_eq() (both
* `static`, but visible in this TU via the white-box #include of
* ../src/sim_verify.c below -- ordinary C translation-unit visibility, not a
* new sharing mechanism). sim_decision_eq() itself (also in sim_verify.c)
* Comparator design: uses the public libxce leaf-level structural
* comparators, job_alloc_eq() (xcealloc.h; compares `from`, excludes only
* instid) and the full-match job_preason_eq() (preason.h; main reason plus
* host- and resource-based detail lists), each reporting a first-difference
* description that the failure message prints. Full-match pending reasons
* are valid here because neither side runs with the scheduler's
* unsatisfiable-allocation cache (no unsatisfiable_lookup_cb is registered),
* so both build the detail lists with the same full per-host computation.
* The white-box #include of ../src/sim_verify.c below stays: sim_loop.c
* calls its decision-level functions. sim_decision_eq() itself (in sim_verify.c)
* is NOT reused directly: it compares a replay_decision_t against a LIVE
* xce_decision_t (recorded-vs-live), a different pair of top-level shapes
* than this file needs (recorded-vs-recorded, replay_decision_t vs
* replay_decision_t, R vs S) -- but the SAME xce_job_alloc_t/
* xce_job_preason_t leaf types and their SAME field-by-field comparators
* apply either way, so this file's own small
* xce_job_preason_t leaf types and the SAME public field-by-field
* comparators apply either way, so this file's own small
* replay_decision_content_eq() below delegates to those two leaf
* comparators instead of re-deriving the field walk from scratch.
*
@ -171,6 +176,7 @@
#include "kvmgr.h"
#include "preason.h"
#include "scheduler.h"
#include "xcealloc.h"
#include "xstring.h"
/* Pull in the real functions under test into this TU (white-box #include,
@ -868,41 +874,81 @@ static replay_session_t* decode_session_after_skip(const char* path, int n_skip)
* (a different comparison pair than sim_verify.c's own sim_decision_eq(),
* which compares a recorded replay_decision_t against a LIVE xce_decision_t
* -- see this file's own header comment for why a small new comparator is
* written here rather than reusing sim_decision_eq() itself, while still
* reusing its two LEAF comparators, sim_verify_job_alloc_eq()/
* sim_verify_job_preason_eq() -- both `static` in sim_verify.c but visible
* in this TU via this file's white-box #include of that file above).
* written here rather than reusing sim_decision_eq() itself), delegating the
* payload to the public libxce comparators job_alloc_eq()/job_preason_eq().
* On mismatch, *why (when `why` is non-NULL) is a malloc'd description of
* the first difference, which the caller prints and free()s.
* AC 7.1 excludes ReplayHeader/SessionSummary from the equivalence claim --
* this function, and every call site below, touches only `body_which` and
* the DISPATCH/PEND payload, never `ts` or any summary field.
*/
static int replay_decision_content_eq(const replay_decision_t* r,
const replay_decision_t* s)
const replay_decision_t* s,
char** why)
{
char buf[128];
if (why != NULL) {
*why = NULL;
}
if ((r == NULL) || (s == NULL)) {
if (why != NULL) {
*why = strdup("decision: NULL argument");
}
return 0;
}
if (r->body_which != s->body_which) {
if (why != NULL) {
snprintf(buf, sizeof(buf), "body_which: %d != %d",
(int)r->body_which, (int)s->body_which);
*why = strdup(buf);
}
return 0;
}
switch (r->body_which) {
case ReplayDecision_body_dispatch:
if ((r->body.dispatch == NULL) || (s->body.dispatch == NULL)) {
if (why != NULL) {
*why = strdup("dispatch: NULL body");
}
return 0;
}
return sim_verify_job_alloc_eq(r->body.dispatch->alloc,
s->body.dispatch->alloc);
/* Public libxce comparator: compares `from` too (both sides stamp it
* from the deciding session's start), excludes only instid. */
return job_alloc_eq(r->body.dispatch->alloc,
s->body.dispatch->alloc, why);
case ReplayDecision_body_pend:
if ((r->body.pend == NULL) || (s->body.pend == NULL)) {
if (why != NULL) {
*why = strdup("pend: NULL body");
}
return 0;
}
return (r->body.pend->jobid == s->body.pend->jobid)
&& sim_verify_job_preason_eq(r->body.pend->reason,
s->body.pend->reason);
if (r->body.pend->jobid != s->body.pend->jobid) {
if (why != NULL) {
snprintf(buf, sizeof(buf), "pend.jobid: %llu != %llu",
(unsigned long long)r->body.pend->jobid,
(unsigned long long)s->body.pend->jobid);
*why = strdup(buf);
}
return 0;
}
/* Full match (main reason + host- and resource-based detail lists)
* is valid here, unlike --sim-verify's main-reason-only PEND check
* (bug-1845): this test registers no unsatisfiable_lookup_cb, so
* neither side has the unsatisfiable-allocation cache and both build
* the detail lists with the same full per-host computation. */
return job_preason_eq(r->body.pend->reason,
s->body.pend->reason, why);
default:
if (why != NULL) {
snprintf(buf, sizeof(buf), "body_which: unsupported %d",
(int)r->body_which);
*why = strdup(buf);
}
return 0;
}
}
@ -1004,8 +1050,19 @@ test_normal_mode_recording_and_simulation_replay_produce_identical_decisions(
TEST_ASSERT_EQUAL_INT((int)ReplayDecision_body_pend,
(int)r_session->decisions[i]->body_which);
TEST_ASSERT_TRUE(replay_decision_content_eq(r_session->decisions[i],
s_session->decisions[i]));
{
char* why = NULL;
char msg[512];
int eq = replay_decision_content_eq(r_session->decisions[i],
s_session->decisions[i],
&why);
snprintf(msg, sizeof(msg),
"decision %d: recorded (R) vs simulated (S) differ: %s",
i, (why != NULL) ? why : "(no description)");
free(why);
TEST_ASSERT_TRUE_MESSAGE(eq, msg);
}
}
free_ReplaySession_ptr(&r_session);