X-Lang logo
GitHub
Symbiotic Compiler Advisor

Deep Dive: x-advisor Diagnostic Engine

x-advisor reasons about interactions between semantic contracts, hardware behavior, and runtime structure. It turns hidden performance hazards into actionable compile-time guidance with confidence estimates.

Advisor in Thesis ContextSee Verification Guarantees
Case 1
Symbiotic Diagnosis

Parallel + Memoised Hot Loop

Detect lock contention before it silently erases thread-level speedup.

Observed Symptom

A pure memoised function is called inside a parallel loop. Throughput collapses because all workers serialize on a shared cache lock.

Advisor Diagnosis

x-advisor models the interaction of call frequency, lock cost, and worker count. It flags this as negative synergy even though each individual contract is valid.

Recommended Refactor

Lift shared precomputation outside the loop, switch to thread-local caches, or remove memoisation when hit locality is weak.

What x-advisor optimizes for

Preserve semantic intent while reducing interaction penalties so the generated program is both correct and structurally performant on real hardware.

Analysed Program
pure memoised fn expensive_calc(n: i32) -> i32 {
return n * n + 42;
}
fn simulate(items: &mut [i32]) {
parallel for i in 0..items.len() {
items[i] = expensive_calc(items[i]);
}
}
Advisor Diagnostic Output
ADVICE x_advisor::parallel_cache
function: simulate
confidence: 0.91
risk: shared memo cache lock in parallel region
estimated impact: -37% throughput
suggestion: thread-local cache + merge
Case 2
Symbiotic Diagnosis

Layout Contract With False Sharing Risk

Preserve vector-friendly layout while avoiding multi-core cache-line thrashing.

Observed Symptom

A transformed SoA layout improves SIMD access, but adjacent worker chunks still touch the same cache lines when chunk sizing is too small.

Advisor Diagnosis

The advisor estimates ownership overlap and predicts cache invalidation storms. It reports when memory layout and scheduler policy are fighting each other.

Recommended Refactor

Increase grain size, align partitions to cache-line boundaries, or use static chunk pinning to keep writes disjoint across workers.

What x-advisor optimizes for

Preserve semantic intent while reducing interaction penalties so the generated program is both correct and structurally performant on real hardware.

Analysed Program
#[layout(SoA)]
struct Particle {
x: f64,
y: f64,
vx: f64
}
fn integrate(p: &mut [Particle], dt: f64) {
parallel for i in 0..p.len() {
p[i].x += p[i].vx * dt;
}
}
Advisor Diagnostic Output
WARN x_advisor::false_sharing
function: integrate
confidence: 0.87
cause: worker chunks overlap cache lines
estimated impact: +31% coherence traffic
fix-it: chunk_size = 128 and line-aligned slicing
Case 3
Symbiotic Diagnosis

Missing Invariant Causes Defensive Branch Drift

Turn implicit domain truths into optimizer-grade assumptions and cleaner CFGs.

Observed Symptom

A loop keeps defensive checks because the compiler cannot prove stable bounds. The branch predictor and vectorizer both lose confidence.

Advisor Diagnosis

x-advisor spots repeated guard patterns that are semantically redundant and suggests introducing an explicit invariant contract.

Recommended Refactor

Declare invariant bounds on the state object, then allow lowering to llvm.assume so dead panic paths can be removed safely.

What x-advisor optimizes for

Preserve semantic intent while reducing interaction penalties so the generated program is both correct and structurally performant on real hardware.

Analysed Program
struct SafeBuf {
len: i32,
cap: i32
}
fn push_many(s: &mut SafeBuf, n: i32) {
for _i in 0..n {
if s.len < s.cap {
s.len += 1;
}
}
}
Advisor Diagnostic Output
FIX-IT x_advisor::invariant_hint
function: push_many
confidence: 0.89
rewrite: add invariant { self.len <= self.cap }
result: prune panic edge and simplify CFG