/*
* otTINN v0.25 CONSOLIDATED R3 - Autonomous Grow/Shrink Lifecycle
*
* R3 production baseline consolidates the validated R2 BF518 deployment-latency
* normalization, SIMMEM1 simplification outcome memory, BOOTFIX3/otFILE v2.0.2,
* and SIGNATURE2 as the formal policy interface. Decision semantics and thresholds
* remain unchanged.
*
* R3 preserves the deliberately explicit R2 BF518 HARDWARE PATCH:
* promotion/dominance latency is measured with the CANDIDATE temporarily
* owning the same fast-memory opportunity it would have after promotion.
* Shadow latency is still measured and logged, but is not used as deployment
* cost because ACTIVE necessarily occupies scarce fast memory during shadow.
*
* Real BF518 long-duration harness built on the v0.21 validated lifecycle:
* Monitor -> Candidate -> resumable Train -> Validate -> Shadow -> Promote ->
* persistent A/B commit -> Probation -> stable retirement or Rollback.
*
* The harness deliberately uses the existing otRTC and otFILE APIs:
* - RTC timestamps every SD log record;
* - append-only endurance log;
* - fsync on critical events and periodically;
* - A/B lifecycle storage and A/B endurance cursor state;
* - deterministic pseudo-random world evolution from a logged seed.
*
* BF518 rules:
* - 4 KiB application stack: no large local arrays;
* - control-plane objects in FAST_DATA_2 / MEM_L2_DATA_A;
* - cold/persistent objects and work buffers in SDRAM_DATA;
* - Q15 runtime placement remains managed by otTinn fast heaps.
*/
#if defined(_WIN32) || defined(__WIN32__)
#include <stdio.h>
#include <string.h>
#include "otNeuralNetwork.h"
#include "otNeuralScenario.h"
#include "otNeuralMonitor.h"
#include "otNeuralTraining.h"
#include "otNeuralModelLifecycle.h"
#include "otNeuralLifecycleStorage.h"
#include "otNeuralAutonomy.h"
static bool step6PromotionExplainabilitySelfTest(otNNValidationReport & validation,
otNNExecutionMetrics & execution,
const otNNComplexityReport & candidateComplexity,
otNNDominanceReport & dominance)
{
otNeuralAutonomyController controller;
otNNPromotionGateReport gates;
otNNShadowReport shadow;
static otNNComplexityReport activeComplexity;
static otNNMeaningfulImprovementReport improvement;
static otNNPromotionDecisionTrace trace;
/* Build a fully valid quality/Q15/shadow context so only the Step 5/6
dominance relation and its derived explanation change between checks. */
controller.init(0);
memset(&validation, 0, sizeof(validation));
validation.valid = 1;
validation.active.valid = 1;
validation.candidate.valid = 1;
validation.active.samples = 400UL;
validation.candidate.samples = 400UL;
validation.active.classificationAvailable = 1;
validation.candidate.classificationAvailable = 1;
validation.active.accuracyPercent = 90.0f;
validation.candidate.accuracyPercent = 90.5f;
validation.active.meanAbsError = 0.100f;
validation.candidate.meanAbsError = 0.095f;
validation.active.q15Prepared = 1;
validation.candidate.q15Prepared = 1;
validation.active.q15Evaluated = 1;
validation.candidate.q15Evaluated = 1;
validation.active.q15AccuracyPercent = 90.0f;
validation.candidate.q15AccuracyPercent = 90.5f;
validation.active.q15MeanAbsError = 0.100f;
validation.candidate.q15MeanAbsError = 0.095f;
memset(&execution, 0, sizeof(execution));
execution.q15LatencyValid = 1;
execution.q15LatencyUs = candidateComplexity.q15LatencyValid ?
candidateComplexity.q15LatencyUs : 7.5f;
memset(&shadow, 0, sizeof(shadow));
shadow.valid = 1;
shadow.activeExecutedFirst = 1;
shadow.candidateAuthority = 0;
shadow.samples = 400UL;
activeComplexity = candidateComplexity;
activeComplexity.valid = 1;
if(activeComplexity.parameters > 10UL) activeComplexity.parameters -= 10UL;
if(activeComplexity.macsPerInference > 10UL) activeComplexity.macsPerInference -= 10UL;
if(activeComplexity.floatRuntimeBytes > 40UL) activeComplexity.floatRuntimeBytes -= 40UL;
if(activeComplexity.trainingWorkspaceBytes > 20UL) activeComplexity.trainingWorkspaceBytes -= 20UL;
if(activeComplexity.q15RuntimeBytes > 20UL) activeComplexity.q15RuntimeBytes -= 20UL;
activeComplexity.q15LatencyValid = 1;
if(!activeComplexity.q15LatencyValid || activeComplexity.q15LatencyUs <= 0.0f)
activeComplexity.q15LatencyUs = 7.0f;
memset(&improvement, 0, sizeof(improvement));
improvement.valid = 1;
improvement.floatAccuracyAvailable = 1;
improvement.floatAccuracyGainPoints = 0.5f;
improvement.floatAccuracyMeaningful = 1;
improvement.floatMeanErrorAvailable = 1;
improvement.floatMeanErrorReductionRatio = 0.05f;
improvement.floatMeanErrorMeaningful = 1;
improvement.q15AccuracyAvailable = 1;
improvement.q15AccuracyGainPoints = 0.5f;
improvement.q15AccuracyMeaningful = 1;
improvement.q15MeanErrorAvailable = 1;
improvement.q15MeanErrorReductionRatio = 0.05f;
improvement.q15MeanErrorMeaningful = 1;
/* Candidate Pareto dominance passes and Step 6 explains why. */
memset(&dominance, 0, sizeof(dominance));
dominance.valid = 1;
dominance.candidateParetoDominates = 1;
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &dominance, &shadow, gates) ||
!gates.valid || !gates.dominanceApplied || !gates.dominanceReportGate ||
!gates.dominanceGate || !gates.eligible ||
!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, &shadow, trace) ||
!trace.valid || !trace.finalDecisionKnown || !trace.eligible ||
trace.reason != OTNN_DECISION_PROMOTE_PARETO ||
strcmp(controller.promotionDecisionReasonName(trace.reason), "PROMOTE_PARETO") != 0)
return false;
/* The same passed validation without shadow is explicitly pending, not reject. */
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &dominance, 0, gates) ||
!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, 0, trace) ||
trace.finalDecisionKnown || trace.eligible ||
trace.reason != OTNN_DECISION_WAIT_SHADOW)
return false;
/* ACTIVE dominance blocks and receives a stable reason code. */
memset(&dominance, 0, sizeof(dominance));
dominance.valid = 1;
dominance.activeParetoDominates = 1;
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &dominance, &shadow, gates) ||
gates.dominanceGate || gates.eligible ||
!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, &shadow, trace) ||
trace.reason != OTNN_DECISION_REJECT_ACTIVE_DOMINATES)
return false;
/* Meaningful bounded tradeoff passes. */
memset(&dominance, 0, sizeof(dominance));
dominance.valid = 1;
dominance.candidateBoundedTradeoff = 1;
dominance.meaningfulQualityGain = 1;
dominance.boundedExtraCost = 1;
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &dominance, &shadow, gates) ||
!gates.dominanceGate || !gates.eligible ||
!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, &shadow, trace) ||
trace.reason != OTNN_DECISION_PROMOTE_BOUNDED_TRADEOFF)
return false;
/* Equivalent and excessive relative-cost cases are differentiated. */
memset(&dominance, 0, sizeof(dominance));
dominance.valid = 1;
dominance.equivalent = 1;
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &dominance, &shadow, gates) ||
gates.dominanceGate || gates.eligible ||
!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, &shadow, trace) ||
trace.reason != OTNN_DECISION_REJECT_EQUIVALENT)
return false;
memset(&dominance, 0, sizeof(dominance));
dominance.valid = 1;
dominance.unresolvedTradeoff = 1;
dominance.meaningfulQualityGain = 1;
dominance.boundedExtraCost = 0;
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &dominance, &shadow, gates) ||
gates.dominanceGate || gates.eligible ||
!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, &shadow, trace) ||
trace.reason != OTNN_DECISION_REJECT_RELATIVE_COST)
return false;
/* Invalid supplied evidence blocks and is distinguishable from policy reject. */
memset(&dominance, 0, sizeof(dominance));
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &dominance, &shadow, gates) ||
gates.dominanceReportGate || gates.dominanceGate || gates.eligible ||
!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, &shadow, trace) ||
trace.reason != OTNN_DECISION_REJECT_DOMINANCE_REPORT)
return false;
/* Historical overload remains source/behavior compatible. */
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &shadow, gates) ||
gates.dominanceApplied || !gates.dominanceGate || !gates.eligible)
return false;
return true;
}
static bool topologyStep11CoreSelfTest()
{
otNNTopology one;
otNNTopology multi;
otNNTopology deep;
otTinn model;
otTinn widenedModel;
otTinnWarmStartReport warmReport;
otTinnQ15MemoryInfo info;
otNNComplexityReport complexity;
otNNExecutionMetrics complexityExecution;
otNNModelDescriptor complexityDescriptor;
otNNComplexityGatePolicy complexityPolicy;
otNNComplexityGateReport complexityGates;
otNNMeaningfulImprovementPolicy improvementPolicy;
otNNMeaningfulImprovementReport improvementReport;
otNNValidationReport improvementValidation;
otNNDominancePolicy dominancePolicy;
otNNDominanceReport dominanceReport;
otNNComparisonReport dominanceComparison;
otNNComplexityReport activeDominanceComplexity;
otNNComplexityReport candidateDominanceComplexity;
float in[4];
float target[2];
float * out;
float f0, f1, q0, q1, d0, d1;
short qin[4];
short sourceRaw[2];
const short * raw;
int i;
in[0] = -0.75f;
in[1] = -0.10f;
in[2] = 0.35f;
in[3] = 0.90f;
target[0] = 1.0f;
target[1] = 0.0f;
otTinn::makeSingleHiddenTopology(one, 4, 2, 3);
if(!otTinn::supportsTopology(one) || !otTinn::supportsTrainingTopology(one) ||
!otTinn::supportsQ15Topology(one) ||
!otTinn::supportsLegacySerializationTopology(one) ||
!otTinn::supportsTrainingCheckpointTopology(one))
return false;
multi = one;
multi.hiddenLayers = 2;
multi.hidden[0] = 3;
multi.hidden[1] = 2;
if(!otTinn::supportsTopology(multi) || !otTinn::supportsTrainingTopology(multi) ||
!otTinn::supportsQ15Topology(multi) ||
!otTinn::supportsTrainingCheckpointTopology(multi) ||
otTinn::supportsLegacySerializationTopology(multi))
return false;
if(!model.init(multi, 0) || !model.valid())
return false;
for(i = 0; i < 64; ++i)
if(model.train(in, target, 0.20f) < 0.0f)
return false;
out = model.predict(in);
if(out == 0)
return false;
f0 = out[0];
f1 = out[1];
model.q15MemoryInfo(info);
if(info.totalBytes != 66UL || info.ready)
return false;
if(!model.prepareQ15() || !model.q15Ready())
return false;
model.q15MemoryInfo(info);
if(info.totalBytes != 66UL || !info.ready)
return false;
out = model.predictQ15(in);
if(out == 0)
return false;
q0 = out[0];
q1 = out[1];
d0 = f0 - q0; if(d0 < 0.0f) d0 = -d0;
d1 = f1 - q1; if(d1 < 0.0f) d1 = -d1;
if(d0 > 0.02f || d1 > 0.02f)
return false;
if(!model.quantizeInputQ15(in, qin))
return false;
raw = model.predictQ15Raw(qin);
if(raw == 0)
return false;
d0 = q0 - ((float)raw[0] / 32767.0f); if(d0 < 0.0f) d0 = -d0;
d1 = q1 - ((float)raw[1] / 32767.0f); if(d1 < 0.0f) d1 = -d1;
if(d0 > 0.000001f || d1 > 0.000001f)
return false;
/* Training must invalidate a stale Q15 copy, then allow reconstruction. */
if(model.train(in, target, 0.10f) < 0.0f || model.q15Ready())
return false;
if(!model.prepareQ15())
return false;
/* v0.24 Step 1: the complexity report is descriptive only. Verify exact
topology-derived quantities and transparent pass-through of measured latency. */
memset(&complexityExecution, 0, sizeof(complexityExecution));
complexityExecution.floatLatencyValid = 1;
complexityExecution.floatLatencyUs = 12.5f;
complexityExecution.q15LatencyValid = 1;
complexityExecution.q15LatencyUs = 7.5f;
otNeuralTrainingSession::makeDescriptor(complexityDescriptor, 1UL, 1UL, multi);
if(!otNeuralModelLifecycle::buildComplexityReport(
&model, complexityDescriptor, &complexityExecution, complexity) ||
!complexity.valid || complexity.hiddenLayers != 2 ||
complexity.maxHiddenWidth != 3 || complexity.hiddenNeurons != 5UL ||
complexity.parameters != 25UL || complexity.macsPerInference != 22UL ||
complexity.floatParameterBytes != 100UL ||
complexity.floatRuntimeBytes != 156UL ||
complexity.trainingWorkspaceBytes != 28UL ||
!complexity.q15Ready || complexity.q15RuntimeBytes != 66UL ||
!complexity.floatLatencyValid || complexity.floatLatencyUs != 12.5f ||
!complexity.q15LatencyValid || complexity.q15LatencyUs != 7.5f)
return false;
/* v0.24 Step 2: absolute complexity/resource gates remain independent.
They answer only "can this Candidate fit the configured target envelope?"
and deliberately make no ACTIVE-vs-CANDIDATE value judgement. */
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
!complexityGates.valid || !complexityGates.reportGate ||
!complexityGates.hiddenLayersGate || !complexityGates.hiddenWidthGate ||
!complexityGates.parameterGate || !complexityGates.macGate ||
!complexityGates.floatRuntimeGate || !complexityGates.trainingWorkspaceGate ||
!complexityGates.q15RuntimeGate || !complexityGates.q15NormalGate ||
!complexityGates.floatLatencyGate || !complexityGates.eligible)
return false;
/* Missing mandatory report is a single explicit gate failure, not an
invented failure of every resource dimension. */
if(!otNeuralAutonomyController::evaluateComplexityGates(
0, complexityPolicy, complexityGates) ||
complexityGates.reportGate || complexityGates.eligible ||
!complexityGates.parameterGate || !complexityGates.macGate)
return false;
/* Exercise independent hard-limit failures one by one. */
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.maximumHiddenLayers = 1;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.hiddenLayersGate || complexityGates.eligible)
return false;
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.maximumHiddenWidth = 2;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.hiddenWidthGate || complexityGates.eligible)
return false;
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.maximumParameters = 24UL;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.parameterGate || complexityGates.eligible)
return false;
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.maximumMacsPerInference = 21UL;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.macGate || complexityGates.eligible)
return false;
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.maximumFloatRuntimeBytes = 155UL;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.floatRuntimeGate || complexityGates.eligible)
return false;
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.maximumTrainingWorkspaceBytes = 27UL;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.trainingWorkspaceGate || complexityGates.eligible)
return false;
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.maximumQ15RuntimeBytes = 65UL;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.q15RuntimeGate || complexityGates.eligible)
return false;
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.requireFloatLatency = 1;
complexityPolicy.maximumFloatLatencyUs = 12.0f;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.floatLatencyGate || complexityGates.eligible)
return false;
/* v0.24 Step 3: meaningful quality improvement is evaluated per metric.
It is descriptive only here and is NOT wired into promotion eligibility. */
otNeuralModelLifecycle::defaultMeaningfulImprovementPolicy(improvementPolicy);
if(improvementPolicy.minimumFloatAccuracyGainPoints != 0.25f ||
improvementPolicy.minimumFloatMeanErrorReductionRatio != 0.02f ||
improvementPolicy.minimumQ15AccuracyGainPoints != 0.25f ||
improvementPolicy.minimumQ15MeanErrorReductionRatio != 0.02f)
return false;
memset(&improvementValidation, 0, sizeof(improvementValidation));
improvementValidation.valid = 1;
improvementValidation.active.valid = 1;
improvementValidation.candidate.valid = 1;
improvementValidation.active.samples = 400UL;
improvementValidation.candidate.samples = 400UL;
improvementValidation.active.classificationAvailable = 1;
improvementValidation.candidate.classificationAvailable = 1;
improvementValidation.active.accuracyPercent = 90.0f;
improvementValidation.candidate.accuracyPercent = 90.10f;
improvementValidation.active.meanAbsError = 0.100f;
improvementValidation.candidate.meanAbsError = 0.099f;
improvementValidation.active.q15Evaluated = 1;
improvementValidation.candidate.q15Evaluated = 1;
improvementValidation.active.q15AccuracyPercent = 89.0f;
improvementValidation.candidate.q15AccuracyPercent = 89.10f;
improvementValidation.active.q15MeanAbsError = 0.110f;
improvementValidation.candidate.q15MeanAbsError = 0.109f;
/* Small positive changes remain below the configured thresholds. */
if(!otNeuralModelLifecycle::evaluateMeaningfulImprovement(
improvementValidation, improvementPolicy, improvementReport) ||
!improvementReport.valid || !improvementReport.floatAccuracyAvailable ||
!improvementReport.floatMeanErrorAvailable ||
!improvementReport.q15AccuracyAvailable ||
!improvementReport.q15MeanErrorAvailable ||
improvementReport.floatAccuracyMeaningful ||
improvementReport.floatMeanErrorMeaningful ||
improvementReport.q15AccuracyMeaningful ||
improvementReport.q15MeanErrorMeaningful)
return false;
/* Each quality/error criterion can cross its threshold independently. */
improvementValidation.candidate.accuracyPercent = 90.50f;
improvementValidation.candidate.meanAbsError = 0.097f;
improvementValidation.candidate.q15AccuracyPercent = 89.50f;
improvementValidation.candidate.q15MeanAbsError = 0.106f;
if(!otNeuralModelLifecycle::evaluateMeaningfulImprovement(
improvementValidation, improvementPolicy, improvementReport) ||
!improvementReport.floatAccuracyMeaningful ||
!improvementReport.floatMeanErrorMeaningful ||
!improvementReport.q15AccuracyMeaningful ||
!improvementReport.q15MeanErrorMeaningful)
return false;
/* Regression is never a meaningful improvement. */
improvementValidation.candidate.accuracyPercent = 89.0f;
improvementValidation.candidate.meanAbsError = 0.110f;
improvementValidation.candidate.q15AccuracyPercent = 88.0f;
improvementValidation.candidate.q15MeanAbsError = 0.120f;
if(!otNeuralModelLifecycle::evaluateMeaningfulImprovement(
improvementValidation, improvementPolicy, improvementReport) ||
improvementReport.floatAccuracyMeaningful ||
improvementReport.floatMeanErrorMeaningful ||
improvementReport.q15AccuracyMeaningful ||
improvementReport.q15MeanErrorMeaningful)
return false;
/* v0.24 Step 4: dominance remains vector/logical, never scalar.
Exercise the four cases required by the v0.24 plan. */
otNeuralModelLifecycle::defaultDominancePolicy(dominancePolicy);
if(dominancePolicy.maximumParameterIncreaseRatio != 1.0f ||
dominancePolicy.maximumMacIncreaseRatio != 1.0f ||
dominancePolicy.maximumFloatRuntimeIncreaseRatio != 1.0f ||
dominancePolicy.maximumTrainingWorkspaceIncreaseRatio != 1.0f ||
dominancePolicy.maximumQ15RuntimeIncreaseRatio != 1.0f ||
dominancePolicy.maximumQ15LatencyIncreaseRatio != 1.0f)
return false;
memset(&dominanceComparison, 0, sizeof(dominanceComparison));
dominanceComparison.valid = 1;
dominanceComparison.floatAccuracy.available = 1;
dominanceComparison.floatAccuracy.relation = OTNN_COMPARE_CANDIDATE_BETTER;
dominanceComparison.floatMeanAbsError.available = 1;
dominanceComparison.floatMeanAbsError.relation = OTNN_COMPARE_EQUAL;
dominanceComparison.q15Accuracy.available = 1;
dominanceComparison.q15Accuracy.relation = OTNN_COMPARE_EQUAL;
dominanceComparison.q15MeanAbsError.available = 1;
dominanceComparison.q15MeanAbsError.relation = OTNN_COMPARE_EQUAL;
memset(&improvementReport, 0, sizeof(improvementReport));
improvementReport.valid = 1;
memset(&activeDominanceComplexity, 0, sizeof(activeDominanceComplexity));
activeDominanceComplexity.valid = 1;
activeDominanceComplexity.parameters = 1000UL;
activeDominanceComplexity.macsPerInference = 900UL;
activeDominanceComplexity.floatRuntimeBytes = 5000UL;
activeDominanceComplexity.trainingWorkspaceBytes = 1000UL;
activeDominanceComplexity.q15Ready = 1;
activeDominanceComplexity.q15RuntimeBytes = 2500UL;
activeDominanceComplexity.q15LatencyValid = 1;
activeDominanceComplexity.q15LatencyUs = 100.0f;
candidateDominanceComplexity = activeDominanceComplexity;
candidateDominanceComplexity.parameters = 3000UL;
candidateDominanceComplexity.macsPerInference = 2700UL;
candidateDominanceComplexity.floatRuntimeBytes = 15000UL;
candidateDominanceComplexity.trainingWorkspaceBytes = 3000UL;
candidateDominanceComplexity.q15RuntimeBytes = 7500UL;
candidateDominanceComplexity.q15LatencyUs = 300.0f;
/* Slightly better but ~3x larger: unresolved, not justified. */
if(!otNeuralModelLifecycle::evaluateDominance(
dominanceComparison, improvementReport, activeDominanceComplexity,
candidateDominanceComplexity, dominancePolicy, dominanceReport) ||
!dominanceReport.valid || dominanceReport.candidateParetoDominates ||
dominanceReport.activeParetoDominates ||
dominanceReport.candidateBoundedTradeoff ||
!dominanceReport.unresolvedTradeoff || dominanceReport.boundedExtraCost)
return false;
/* Meaningfully better with +50% bounded cost: explicit bounded trade-off. */
improvementReport.floatAccuracyMeaningful = 1;
candidateDominanceComplexity.parameters = 1500UL;
candidateDominanceComplexity.macsPerInference = 1350UL;
candidateDominanceComplexity.floatRuntimeBytes = 7500UL;
candidateDominanceComplexity.trainingWorkspaceBytes = 1500UL;
candidateDominanceComplexity.q15RuntimeBytes = 3750UL;
candidateDominanceComplexity.q15LatencyUs = 150.0f;
if(!otNeuralModelLifecycle::evaluateDominance(
dominanceComparison, improvementReport, activeDominanceComplexity,
candidateDominanceComplexity, dominancePolicy, dominanceReport) ||
!dominanceReport.candidateBoundedTradeoff ||
dominanceReport.candidateParetoDominates ||
dominanceReport.activeParetoDominates ||
!dominanceReport.boundedExtraCost)
return false;
/* Larger with equal quality: ACTIVE Pareto-dominates. */
dominanceComparison.floatAccuracy.relation = OTNN_COMPARE_EQUAL;
improvementReport.floatAccuracyMeaningful = 0;
if(!otNeuralModelLifecycle::evaluateDominance(
dominanceComparison, improvementReport, activeDominanceComplexity,
candidateDominanceComplexity, dominancePolicy, dominanceReport) ||
!dominanceReport.activeParetoDominates ||
dominanceReport.candidateParetoDominates ||
dominanceReport.candidateBoundedTradeoff)
return false;
/* Smaller with equal quality: Candidate Pareto-dominates. */
candidateDominanceComplexity.parameters = 800UL;
candidateDominanceComplexity.macsPerInference = 720UL;
candidateDominanceComplexity.floatRuntimeBytes = 4000UL;
candidateDominanceComplexity.trainingWorkspaceBytes = 800UL;
candidateDominanceComplexity.q15RuntimeBytes = 2000UL;
candidateDominanceComplexity.q15LatencyUs = 80.0f;
if(!otNeuralModelLifecycle::evaluateDominance(
dominanceComparison, improvementReport, activeDominanceComplexity,
candidateDominanceComplexity, dominancePolicy, dominanceReport) ||
!dominanceReport.candidateParetoDominates ||
dominanceReport.activeParetoDominates ||
dominanceReport.candidateBoundedTradeoff)
return false;
/* v0.24 Step 5: Step 4 evidence is now an independent promotion gate. */
if(!step6PromotionExplainabilitySelfTest(improvementValidation, complexityExecution,
candidateDominanceComplexity, dominanceReport))
return false;
model.close();
deep = one;
deep.hiddenLayers = 4;
deep.hidden[0] = 4;
deep.hidden[1] = 3;
deep.hidden[2] = 3;
deep.hidden[3] = 2;
if(!otTinn::supportsQ15Topology(deep) || !model.init(deep, 0))
return false;
model.q15MemoryInfo(info);
if(info.totalBytes != 130UL)
return false;
if(!model.prepareQ15() || model.predictQ15(in) == 0)
return false;
model.close();
/* Step 9: preserve the current function when retrying or widening at equal
depth. Width expansion must preserve both float and raw Q15 outputs before
any new training sample is applied. Depth changes deliberately stay fresh. */
if(!model.init(one, 0))
return false;
out = model.predict(in);
if(out == 0) return false;
f0 = out[0]; f1 = out[1];
if(!model.prepareQ15() || !model.quantizeInputQ15(in, qin)) return false;
raw = model.predictQ15Raw(qin);
if(raw == 0) return false;
sourceRaw[0] = raw[0]; sourceRaw[1] = raw[1];
multi = one;
multi.hidden[0] = 5;
if(!widenedModel.init(multi, 0)) return false;
if(!widenedModel.warmStartFrom(model, warmReport) ||
warmReport.mode != OTNN_WARMSTART_FUNCTION_PRESERVING_WIDEN ||
!warmReport.functionPreserved || warmReport.copiedWeights != 18UL ||
warmReport.zeroedWeights != 4UL || warmReport.retainedRandomWeights != 8UL)
return false;
out = widenedModel.predict(in);
if(out == 0 || out[0] != f0 || out[1] != f1) return false;
if(!widenedModel.prepareQ15() || !widenedModel.quantizeInputQ15(in, qin)) return false;
raw = widenedModel.predictQ15Raw(qin);
if(raw == 0 || raw[0] != sourceRaw[0] || raw[1] != sourceRaw[1]) return false;
widenedModel.close();
if(!widenedModel.init(one, 0) ||
!widenedModel.warmStartFrom(model, warmReport) ||
warmReport.mode != OTNN_WARMSTART_EXACT_CLONE || !warmReport.functionPreserved)
return false;
out = widenedModel.predict(in);
if(out == 0 || out[0] != f0 || out[1] != f1) return false;
/* v0.25 Step 2: same-depth narrowing uses deterministic structured
PRUNE-COPY. It preserves selected trained structure but deliberately
does not claim exact function preservation. Repeating the transform
must be bit-deterministic regardless of the destination random init. */
multi = one;
multi.hidden[0] = 2;
widenedModel.close();
if(!widenedModel.init(multi, 0) ||
!widenedModel.warmStartFrom(model, warmReport) ||
warmReport.mode != OTNN_WARMSTART_STRUCTURED_PRUNE_COPY ||
warmReport.functionPreserved || warmReport.copiedWeights != 12UL ||
warmReport.selectedNeurons != 2UL || warmReport.prunedNeurons != 1UL)
return false;
out = widenedModel.predict(in);
if(out == 0) return false;
q0 = out[0]; q1 = out[1];
if(!widenedModel.prepareQ15() || widenedModel.predictQ15(in) == 0) return false;
widenedModel.close();
if(!widenedModel.init(multi, 0) ||
!widenedModel.warmStartFrom(model, warmReport)) return false;
out = widenedModel.predict(in);
if(out == 0 || out[0] != q0 || out[1] != q1) return false;
deep = one;
deep.hiddenLayers = 2;
deep.hidden[0] = 3;
deep.hidden[1] = 2;
widenedModel.close();
if(!widenedModel.init(deep, 0)) return false;
if(widenedModel.warmStartFrom(model, warmReport)) return false;
widenedModel.close();
model.close();
/* Step 6/7: deterministic bounded architecture escalation + resource envelope. */
{
otNNTopology active;
otNNArchitecturePolicy policy;
otNNArchitecturePlan plan;
otTinn::makeSingleHiddenTopology(active, 256, 10, 28);
otNeuralAutonomyController::defaultArchitecturePolicy(policy);
if(!otNeuralAutonomyController::planCandidateTopology(active, 0UL, policy, plan) ||
plan.changed || plan.topology.hiddenLayers != 1 || plan.topology.hidden[0] != 28) return false;
if(!otNeuralAutonomyController::planCandidateTopology(active, 1UL, policy, plan) ||
plan.changed || plan.topology.hidden[0] != 28) return false;
if(!otNeuralAutonomyController::planCandidateTopology(active, 2UL, policy, plan) ||
!plan.changed || plan.topology.hiddenLayers != 1 || plan.topology.hidden[0] != 48) return false;
if(!otNeuralAutonomyController::planCandidateTopology(active, 3UL, policy, plan) ||
plan.topology.hiddenLayers != 1 || plan.topology.hidden[0] != 56) return false;
if(!otNeuralAutonomyController::planCandidateTopology(active, 4UL, policy, plan) ||
plan.topology.hiddenLayers != 2 || plan.topology.hidden[0] != 48 ||
plan.topology.hidden[1] != 24 || plan.parameters != 13683UL) return false;
if(!otNeuralAutonomyController::planCandidateTopology(active, 6UL, policy, plan) ||
plan.topology.hiddenLayers != 3 || plan.topology.hidden[0] != 48 ||
plan.topology.hidden[1] != 24 || plan.topology.hidden[2] != 16) return false;
if(!otNeuralAutonomyController::planCandidateTopology(active, 8UL, policy, plan) ||
plan.topology.hiddenLayers != 4 || plan.topology.hidden[0] != 48 ||
plan.topology.hidden[1] != 24 || plan.topology.hidden[2] != 16 ||
plan.topology.hidden[3] != 8) return false;
if(!otNeuralAutonomyController::planCandidateTopology(active, 99UL, policy, plan) ||
plan.stage != 9 || plan.topology.hiddenLayers != 4 ||
plan.topology.hidden[0] != 56 || plan.topology.hidden[1] != 32 ||
plan.topology.hidden[2] != 16 || plan.topology.hidden[3] != 8) return false;
policy.maximumParameters = 10000UL;
if(!otNeuralAutonomyController::planCandidateTopology(active, 4UL, policy, plan) ||
!plan.resourceLimited || !plan.saturated || plan.changed ||
plan.topology.hidden[0] != 28) return false;
/* Step 7: a measured resource ceiling can skip a wide stage and accept
the next deterministic narrower/deeper topology. */
otNeuralAutonomyController::defaultArchitecturePolicy(policy);
if(!otNeuralAutonomyController::planCandidateTopologyAtStage(
active, 3UL, 3UL, 14500UL, policy, plan) ||
plan.requestedStage != 3 || plan.stage != 4 || plan.skippedStages != 1 ||
!plan.resourceLimited || plan.saturated ||
plan.topology.hiddenLayers != 2 || plan.topology.hidden[0] != 48 ||
plan.topology.hidden[1] != 24 || plan.parameters != 13683UL) return false;
if(!otNeuralAutonomyController::planCandidateTopologyAtStage(
active, 5UL, 4UL, 15000UL, policy, plan) ||
plan.stage != 6 || plan.skippedStages != 1 ||
plan.parameters != 13988UL || plan.saturated) return false;
if(!otNeuralAutonomyController::planCandidateTopologyAtStage(
active, 3UL, 3UL, 13000UL, policy, plan) ||
!plan.saturated || !plan.resourceLimited || plan.changed ||
plan.topology.hiddenLayers != 1 || plan.topology.hidden[0] != 28 ||
plan.parameters != 7450UL) return false;
/* Step 8: skip stages with conclusive outcomes in the current episode. */
if(!otNeuralAutonomyController::planCandidateTopologyWithHistory(
active, 2UL, 2UL, 0UL, (1UL << 2) | (1UL << 3), policy, plan) ||
plan.stage != 4 || !plan.historyLimited || plan.historySkippedStages != 2 ||
plan.topology.hiddenLayers != 2 || plan.topology.hidden[0] != 48 ||
plan.topology.hidden[1] != 24 || plan.parameters != 13683UL) return false;
if(!otNeuralAutonomyController::planCandidateTopologyWithHistory(
active, 9UL, 7UL, 0UL, (1UL << 9), policy, plan) ||
!plan.saturated || !plan.historyLimited || plan.changed ||
plan.topology.hidden[0] != 28) return false;
}
/* v0.25 Step 1: deterministic monotonic simplification planner.
No training/promotion decision is made here; topology planning only. */
{
otNNSimplificationPolicy policy;
otNNSimplificationPlan plan;
otNNTopology active;
otNeuralAutonomyController::defaultSimplificationPolicy(policy);
otTinn::makeSingleHiddenTopology(active, 256, 10, 28);
if(!otNeuralAutonomyController::planSimplerTopology(active, 0UL, policy, plan) ||
!plan.valid || !plan.changed || plan.saturated ||
plan.lastAction != OTNN_SIMPLIFY_NARROW_HIDDEN ||
plan.lastHiddenIndex != 0 || plan.topology.hiddenLayers != 1 ||
plan.topology.hidden[0] != 24 || plan.parameters != 6386UL ||
plan.parameters >= plan.activeParameters) return false;
if(!otNeuralAutonomyController::planSimplerTopology(active, 2UL, policy, plan) ||
!plan.changed || !plan.saturated || plan.appliedSteps != 3 ||
plan.topology.hiddenLayers != 1 || plan.topology.hidden[0] != 8 ||
plan.parameters != 2130UL) return false;
memset(&active, 0, sizeof(active));
active.inputs = 256; active.outputs = 10; active.hiddenLayers = 4;
active.hidden[0] = 48; active.hidden[1] = 24;
active.hidden[2] = 16; active.hidden[3] = 8;
if(!otNeuralAutonomyController::planSimplerTopology(active, 0UL, policy, plan) ||
plan.topology.hidden[0] != 48 || plan.topology.hidden[1] != 24 ||
plan.topology.hidden[2] != 8 || plan.topology.hidden[3] != 8 ||
plan.parameters != 13781UL) return false;
if(!otNeuralAutonomyController::planSimplerTopology(active, 8UL, policy, plan) ||
plan.lastAction != OTNN_SIMPLIFY_REMOVE_DEEPEST ||
plan.topology.hiddenLayers != 3 ||
plan.topology.hidden[0] != 8 || plan.topology.hidden[1] != 8 ||
plan.topology.hidden[2] != 8 || plan.parameters != 2260UL) return false;
if(!otNeuralAutonomyController::planSimplerTopology(active, 10UL, policy, plan) ||
!plan.saturated || plan.topology.hiddenLayers != 1 ||
plan.topology.hidden[0] != 8 || plan.parameters != 2130UL) return false;
policy.enabled = 0;
if(!otNeuralAutonomyController::planSimplerTopology(active, 0UL, policy, plan) ||
plan.changed || plan.parameters != 14037UL ||
plan.topology.hiddenLayers != 4) return false;
}
return true;
}
static void step10HostCleanupFiles()
{
const char * names[] = {
"v023_step10_host_lifecycle_A.otl", "v023_step10_host_lifecycle_B.otl",
"v023_step10_host_lifecycle_A_active.otm", "v023_step10_host_lifecycle_A_candidate.otm", "v023_step10_host_lifecycle_A_previous.otm",
"v023_step10_host_lifecycle_B_active.otm", "v023_step10_host_lifecycle_B_candidate.otm", "v023_step10_host_lifecycle_B_previous.otm",
"v023_step10_host_wide_A.otm", "v023_step10_host_wide_A.ots", "v023_step10_host_wide_B.otm", "v023_step10_host_wide_B.ots",
"v023_step10_host_deep_A.otm", "v023_step10_host_deep_A.ots", "v023_step10_host_deep_B.otm", "v023_step10_host_deep_B.ots"
};
int i;
for(i = 0; i < (int)(sizeof(names) / sizeof(names[0])); ++i) remove(names[i]);
}
static bool step10HostTrainCheckpointReload(otTinn * model,
const otNNModelDescriptor & descriptor,
const char * prefix)
{
otNeuralFramework framework;
otNeuralTrainingSession training;
otNNTrainingProgress progress;
framework.init(model, 0);
if(!framework.dataset("semeion_bench.data")) return false;
if(!training.init(model, &framework, 0)) return false;
if(!training.beginExisting(descriptor, 1UL, 0.15f, 0.99f,
0x10A00000UL ^ descriptor.modelId)) return false;
if(training.trainSamples(32UL) != 32UL) return false;
if(!training.saveCheckpoint(prefix)) return false;
training.close();
framework.close();
framework.init(model, 0);
if(!framework.dataset("semeion_bench.data")) return false;
if(!training.init(model, &framework, 0)) return false;
if(!training.loadLatestCheckpoint(prefix)) return false;
training.progress(progress);
if(progress.samplesTrained != 32UL) return false;
training.close();
framework.close();
return true;
}
static bool step10AcceleratedLifecycleSelfTest()
{
otTinn model0, model1, model2;
otNeuralModelLifecycle lifecycle;
otNeuralLifecycleStorage storage;
otNNLifecycleCatalogReport catalog;
otNNModelDescriptor activeD, candidateD, restoredD;
otNNArchitecturePolicy policy;
otNNArchitecturePlan plan;
otTinnWarmStartReport warm;
otNNPromotionReport promotion;
otNNRollbackReport rollback;
otNNTopology activeTopology;
step10HostCleanupFiles();
storage.init(0);
if(!model0.load("saved.tinn")) return false;
model0.topology(activeTopology);
otNeuralTrainingSession::makeDescriptor(activeD, 9100UL, 1UL, activeTopology);
if(!lifecycle.attachActive(&model0, activeD)) return false;
if(!storage.saveSnapshot("v023_step10_host_lifecycle", lifecycle, catalog)) return false;
otNeuralAutonomyController::defaultArchitecturePolicy(policy);
/* Stage 2: widening, exact function preservation before short training. */
if(!otNeuralAutonomyController::planCandidateTopologyAtStage(
activeTopology, 2UL, 2UL, 0UL, policy, plan) ||
plan.stage != 2 || plan.topology.hiddenLayers != 1 || plan.topology.hidden[0] != 48)
return false;
otNeuralTrainingSession::makeDescriptor(candidateD, 9101UL, 1UL, plan.topology);
if(!lifecycle.prepareCandidate(&model1, candidateD, 0)) return false;
if(!model1.warmStartFrom(model0, warm) ||
warm.mode != OTNN_WARMSTART_FUNCTION_PRESERVING_WIDEN || !warm.functionPreserved)
return false;
if(!step10HostTrainCheckpointReload(&model1, candidateD, "v023_step10_host_wide")) return false;
if(!model1.prepareQ15()) return false;
if(!storage.saveSnapshot("v023_step10_host_lifecycle", lifecycle, catalog)) return false;
if(!lifecycle.promoteCandidate(promotion)) return false;
if(!storage.saveSnapshot("v023_step10_host_lifecycle", lifecycle, catalog)) return false;
/* Simulated reboot: restore promoted wide ACTIVE + PREVIOUS, then rollback. */
lifecycle.reset(); model0.close(); model1.close(); model2.close();
if(!storage.loadLatestSnapshot("v023_step10_host_lifecycle", lifecycle,
&model0, &model1, &model2, catalog)) return false;
if(!lifecycle.hasPrevious() || !lifecycle.rollbackPrevious(rollback)) return false;
if(lifecycle.candidateModel() != 0) lifecycle.candidateModel()->close();
lifecycle.clearCandidate();
if(!storage.saveSnapshot("v023_step10_host_lifecycle", lifecycle, catalog)) return false;
/* Stage 4: real depth change 28 -> 48 -> 24, fresh init, train/checkpoint/Q15. */
if(!lifecycle.activeDescriptor(activeD)) return false;
if(!otNeuralAutonomyController::planCandidateTopologyAtStage(
activeD.topology, 4UL, 4UL, 0UL, policy, plan) ||
plan.stage != 4 || plan.topology.hiddenLayers != 2 ||
plan.topology.hidden[0] != 48 || plan.topology.hidden[1] != 24)
return false;
otNeuralTrainingSession::makeDescriptor(candidateD, 9102UL, 1UL, plan.topology);
if(!lifecycle.prepareCandidate(&model1, candidateD, 0)) return false;
if(model1.warmStartFrom(*lifecycle.activeModel(), warm)) return false; /* depth change must stay fresh */
if(!step10HostTrainCheckpointReload(&model1, candidateD, "v023_step10_host_deep")) return false;
if(!model1.prepareQ15()) return false;
if(!storage.saveSnapshot("v023_step10_host_lifecycle", lifecycle, catalog)) return false;
/* Simulated reboot with a deep CANDIDATE: restore, Q15 rebuild, promote, persist. */
lifecycle.reset(); model0.close(); model1.close(); model2.close();
if(!storage.loadLatestSnapshot("v023_step10_host_lifecycle", lifecycle,
&model0, &model1, &model2, catalog)) return false;
if(!lifecycle.candidateDescriptor(restoredD) || restoredD.topology.hiddenLayers != 2 ||
restoredD.topology.hidden[0] != 48 || restoredD.topology.hidden[1] != 24)
return false;
if(lifecycle.candidateModel() == 0 || !lifecycle.candidateModel()->prepareQ15()) return false;
if(!lifecycle.promoteCandidate(promotion)) return false;
if(!storage.saveSnapshot("v023_step10_host_lifecycle", lifecycle, catalog)) return false;
/* One more reboot proves the promoted deep topology is durable, then rollback. */
lifecycle.reset(); model0.close(); model1.close(); model2.close();
if(!storage.loadLatestSnapshot("v023_step10_host_lifecycle", lifecycle,
&model0, &model1, &model2, catalog)) return false;
if(!lifecycle.activeDescriptor(restoredD) || restoredD.topology.hiddenLayers != 2 ||
!lifecycle.hasPrevious()) return false;
if(!lifecycle.rollbackPrevious(rollback)) return false;
if(lifecycle.candidateModel() != 0) lifecycle.candidateModel()->close();
lifecycle.clearCandidate();
if(!storage.saveSnapshot("v023_step10_host_lifecycle", lifecycle, catalog)) return false;
lifecycle.reset(); model0.close(); model1.close(); model2.close();
step10HostCleanupFiles();
return true;
}
/* ------------------------------------------------------------------------- */
/* v0.24 Step 7 deterministic end-to-end decision-path regression. */
/* */
/* This is deliberately stronger than a flag/unit test: each case binds real */
/* ACTIVE/CANDIDATE otTinn objects to the lifecycle, derives Step 1..4 */
/* evidence, lets Step 5 gates choose the controller action, verifies Step 6 */
/* reason logging, then executes the real lifecycle PROMOTE or REJECT role */
/* transaction. Tiny networks keep the boot regression cheap and 4 KiB-safe. */
/* ------------------------------------------------------------------------- */
static bool step7RunDecisionScenario(int scenario,
int expectedReason,
int expectPromotion,
otFILE * fs,
const char * label)
{
static otTinn activeModel;
static otTinn candidateModel;
static otNeuralModelLifecycle lifecycle;
static otNeuralAutonomyController controller;
static otNNModelDescriptor activeD;
static otNNModelDescriptor candidateD;
static otNNModelDescriptor afterD;
static otNNTopology activeTopology;
static otNNTopology candidateTopology;
static otNNValidationReport validation;
static otNNExecutionMetrics activeExecution;
static otNNExecutionMetrics candidateExecution;
static otNNComplexityReport activeComplexity;
static otNNComplexityReport candidateComplexity;
static otNNComparisonPolicy comparisonPolicy;
static otNNComparisonReport comparison;
static otNNMeaningfulImprovementPolicy improvementPolicy;
static otNNMeaningfulImprovementReport improvement;
static otNNDominancePolicy dominancePolicy;
static otNNDominanceReport dominance;
static otNNComplexityGatePolicy complexityPolicy;
static otNNPromotionGateReport gates;
static otNNPromotionDecisionTrace trace;
static otNNShadowReport shadow;
static otNNPromotionReport promotion;
static otTinnQ15MemoryInfo activeQ15;
static otTinnQ15MemoryInfo candidateQ15;
static otNNModelPerformanceSignature activeSignature;
static otNNModelPerformanceSignature candidateSignature;
static otNNComparisonReport signatureComparison;
static otNNMeaningfulImprovementReport signatureImprovement;
static otNNDominanceReport signatureDominance;
static otNeuralAutonomyController signatureController;
static otNNPromotionGateReport signatureGates;
static otNNPromotionDecisionTrace signatureTrace;
bool ok = false;
int action;
unsigned long activeId;
unsigned long candidateId;
float candidateAccuracy;
float candidateError;
float candidateQ15Latency;
lifecycle.reset();
activeModel.close();
candidateModel.close();
memset(&activeTopology, 0, sizeof(activeTopology));
memset(&candidateTopology, 0, sizeof(candidateTopology));
activeTopology.inputs = candidateTopology.inputs = 4;
activeTopology.outputs = candidateTopology.outputs = 2;
activeTopology.hiddenLayers = candidateTopology.hiddenLayers = 1;
/* Four deterministic cases from the v0.24 plan. */
switch(scenario)
{
case 1: /* meaningful but far too expensive -> reject relative cost */
activeTopology.hidden[0] = 4;
candidateTopology.hidden[0] = 16;
candidateAccuracy = 90.30f;
candidateError = 0.097f;
candidateQ15Latency = 30.0f;
break;
case 2: /* clearly better, moderately larger -> bounded tradeoff promote */
activeTopology.hidden[0] = 4;
candidateTopology.hidden[0] = 6;
candidateAccuracy = 91.00f;
candidateError = 0.090f;
candidateQ15Latency = 15.0f;
break;
case 3: /* larger with no quality gain -> ACTIVE dominates */
activeTopology.hidden[0] = 4;
candidateTopology.hidden[0] = 6;
candidateAccuracy = 90.00f;
candidateError = 0.100f;
candidateQ15Latency = 15.0f;
break;
case 4: /* simpler at equal quality -> Candidate Pareto dominates */
activeTopology.hidden[0] = 6;
candidateTopology.hidden[0] = 4;
candidateAccuracy = 90.00f;
candidateError = 0.100f;
candidateQ15Latency = 8.0f;
break;
default:
goto cleanup;
}
activeId = 9700UL + (unsigned long)scenario * 2UL;
candidateId = activeId + 1UL;
if(!activeModel.init(activeTopology, fs)) goto cleanup;
otNeuralTrainingSession::makeDescriptor(activeD, activeId, 1UL, activeTopology);
if(!lifecycle.attachActive(&activeModel, activeD)) goto cleanup;
otNeuralTrainingSession::makeDescriptor(candidateD, candidateId, 1UL, candidateTopology);
if(!lifecycle.prepareCandidate(&candidateModel, candidateD, fs)) goto cleanup;
/* Tiny Q15 runtimes make the evidence structurally realistic while keeping
the regression negligible compared with the production networks. */
if(!activeModel.prepareQ15() || !candidateModel.prepareQ15()) goto cleanup;
memset(&activeExecution, 0, sizeof(activeExecution));
memset(&candidateExecution, 0, sizeof(candidateExecution));
activeExecution.q15LatencyValid = 1;
activeExecution.q15LatencyUs = 10.0f;
candidateExecution.q15LatencyValid = 1;
candidateExecution.q15LatencyUs = candidateQ15Latency;
if(!otNeuralModelLifecycle::buildComplexityReport(&activeModel, activeD,
&activeExecution, activeComplexity) ||
!otNeuralModelLifecycle::buildComplexityReport(&candidateModel, candidateD,
&candidateExecution, candidateComplexity)) goto cleanup;
activeModel.q15MemoryInfo(activeQ15);
candidateModel.q15MemoryInfo(candidateQ15);
memset(&validation, 0, sizeof(validation));
validation.valid = 1;
validation.firstRow = 0;
validation.sampleCount = 400;
validation.active.valid = validation.candidate.valid = 1;
validation.active.samples = validation.candidate.samples = 400UL;
validation.active.classificationAvailable = validation.candidate.classificationAvailable = 1;
validation.active.accuracyPercent = 90.0f;
validation.candidate.accuracyPercent = candidateAccuracy;
validation.active.meanAbsError = 0.100f;
validation.candidate.meanAbsError = candidateError;
validation.active.parameterCount = activeComplexity.parameters;
validation.candidate.parameterCount = candidateComplexity.parameters;
validation.active.q15Prepared = validation.candidate.q15Prepared = 1;
validation.active.q15Evaluated = validation.candidate.q15Evaluated = 1;
validation.active.q15AccuracyPercent = 90.0f;
validation.candidate.q15AccuracyPercent = candidateAccuracy;
validation.active.q15MeanAbsError = 0.100f;
validation.candidate.q15MeanAbsError = candidateError;
validation.active.q15Memory = activeQ15;
validation.candidate.q15Memory = candidateQ15;
otNeuralModelLifecycle::defaultComparisonPolicy(comparisonPolicy);
otNeuralModelLifecycle::defaultMeaningfulImprovementPolicy(improvementPolicy);
otNeuralModelLifecycle::defaultDominancePolicy(dominancePolicy);
if(!otNeuralModelLifecycle::evaluateMeaningfulImprovement(
validation, improvementPolicy, improvement)) goto cleanup;
if(!lifecycle.compareCandidate(validation, activeExecution, candidateExecution,
comparisonPolicy, comparison)) goto cleanup;
if(!otNeuralModelLifecycle::evaluateDominance(comparison, improvement,
activeComplexity, candidateComplexity, dominancePolicy, dominance)) goto cleanup;
memset(&activeSignature, 0, sizeof(activeSignature));
memset(&candidateSignature, 0, sizeof(candidateSignature));
if(!otNeuralModelLifecycle::buildModelPerformanceSignature(
activeD, validation.active, activeComplexity, 0,
0, 0UL, 0UL, activeSignature) ||
!otNeuralModelLifecycle::buildModelPerformanceSignature(
candidateD, validation.candidate, candidateComplexity, 0,
0, 0UL, 0UL, candidateSignature)) goto cleanup;
memset(&signatureImprovement, 0, sizeof(signatureImprovement));
memset(&signatureComparison, 0, sizeof(signatureComparison));
memset(&signatureDominance, 0, sizeof(signatureDominance));
if(!otNeuralModelLifecycle::evaluateSignatureMeaningfulImprovement(
activeSignature, candidateSignature, improvementPolicy,
signatureImprovement) ||
!otNeuralModelLifecycle::comparePerformanceSignatures(
activeSignature, candidateSignature, comparisonPolicy,
signatureComparison) ||
!otNeuralModelLifecycle::evaluateSignatureDominance(
signatureComparison, signatureImprovement,
activeSignature, candidateSignature, dominancePolicy,
signatureDominance)) goto cleanup;
if(memcmp(&improvement, &signatureImprovement, sizeof(improvement)) != 0 ||
memcmp(&comparison, &signatureComparison, sizeof(comparison)) != 0 ||
memcmp(&dominance, &signatureDominance, sizeof(dominance)) != 0)
goto cleanup;
controller.init(0);
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
controller.setComplexityGatePolicy(&complexityPolicy);
signatureController.init(0);
signatureController.setComplexityGatePolicy(&complexityPolicy);
controller.setOperatingWindow(OTNN_WINDOW_MAINTENANCE);
controller.observeMonitorState(OTNN_MONITOR_RETRAIN_REQUIRED);
action = controller.nextAction(lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_VALIDATE_CANDIDATE ||
!controller.actionCompleted(action, true)) goto cleanup;
if(!controller.evaluatePromotionGates(validation, candidateExecution,
&candidateComplexity, &dominance, 0, gates)) goto cleanup;
if(!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, 0, trace)) goto cleanup;
memset(&signatureGates, 0, sizeof(signatureGates));
memset(&signatureTrace, 0, sizeof(signatureTrace));
if(!signatureController.evaluatePromotionGates(
activeSignature, candidateSignature, &signatureDominance,
0, signatureGates) ||
!signatureController.buildPromotionDecisionTrace(
activeSignature, candidateSignature, signatureImprovement,
signatureDominance, signatureGates, 0, signatureTrace) ||
memcmp(&gates, &signatureGates, sizeof(gates)) != 0 ||
memcmp(&trace, &signatureTrace, sizeof(trace)) != 0) goto cleanup;
if(expectPromotion)
{
if(trace.reason != OTNN_DECISION_WAIT_SHADOW || trace.finalDecisionKnown)
goto cleanup;
action = controller.nextAction(lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_SHADOW_CANDIDATE ||
!controller.actionCompleted(action, true)) goto cleanup;
memset(&shadow, 0, sizeof(shadow));
shadow.valid = 1;
shadow.activeExecutedFirst = 1;
shadow.candidateAuthority = 0;
shadow.samples = 400UL;
if(!controller.evaluatePromotionGates(validation, candidateExecution,
&candidateComplexity, &dominance, &shadow, gates)) goto cleanup;
if(!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, &shadow, trace)) goto cleanup;
memset(&signatureGates, 0, sizeof(signatureGates));
memset(&signatureTrace, 0, sizeof(signatureTrace));
if(!signatureController.evaluatePromotionGates(
activeSignature, candidateSignature, &signatureDominance,
&shadow, signatureGates) ||
!signatureController.buildPromotionDecisionTrace(
activeSignature, candidateSignature, signatureImprovement,
signatureDominance, signatureGates, &shadow, signatureTrace) ||
memcmp(&gates, &signatureGates, sizeof(gates)) != 0 ||
memcmp(&trace, &signatureTrace, sizeof(trace)) != 0) goto cleanup;
if(!trace.finalDecisionKnown || !trace.eligible || trace.reason != expectedReason)
goto cleanup;
action = controller.nextAction(lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_PROMOTE_CANDIDATE) goto cleanup;
memset(&promotion, 0, sizeof(promotion));
if(!lifecycle.promoteCandidate(promotion) ||
!controller.actionCompleted(action, true)) goto cleanup;
if(!lifecycle.activeDescriptor(afterD) || afterD.modelId != candidateId ||
!lifecycle.hasPrevious() || lifecycle.hasCandidate() ||
controller.phase() != OTNN_AUTONOMY_PROBATION) goto cleanup;
}
else
{
if(!trace.finalDecisionKnown || trace.eligible || trace.reason != expectedReason)
goto cleanup;
action = controller.nextAction(lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_REJECT_CANDIDATE) goto cleanup;
lifecycle.clearCandidate();
if(!controller.actionCompleted(action, true)) goto cleanup;
if(!lifecycle.activeDescriptor(afterD) || afterD.modelId != activeId ||
lifecycle.hasCandidate() || lifecycle.hasPrevious() ||
controller.phase() != OTNN_AUTONOMY_RETRAIN_PENDING) goto cleanup;
if(controller.nextAction(lifecycle, OTNN_TRAINING_PAUSED) !=
OTNN_AUTONOMY_ACTION_CREATE_CANDIDATE) goto cleanup;
}
printf(" Step 7 case %d %-28s : %s -> %s PASS\n",
scenario, label,
otNeuralAutonomyController::promotionDecisionReasonName(trace.reason),
expectPromotion ? "PROMOTE" : "REJECT");
ok = true;
cleanup:
lifecycle.reset();
activeModel.close();
candidateModel.close();
return ok;
}
static bool step7DeterministicDecisionPathSelfTest(otFILE * fs)
{
printf("v0.25 SIGNATURE2 deterministic policy-equivalence validation: START\n");
if(!step7RunDecisionScenario(1, OTNN_DECISION_REJECT_RELATIVE_COST, 0, fs,
"better / >2x cost")) return false;
if(!step7RunDecisionScenario(2, OTNN_DECISION_PROMOTE_BOUNDED_TRADEOFF, 1, fs,
"better / bounded cost")) return false;
if(!step7RunDecisionScenario(3, OTNN_DECISION_REJECT_ACTIVE_DOMINATES, 0, fs,
"larger / no gain")) return false;
if(!step7RunDecisionScenario(4, OTNN_DECISION_PROMOTE_PARETO, 1, fs,
"smaller / equal quality")) return false;
printf("v0.25 SIGNATURE2 deterministic policy-equivalence validation: PASS\n");
return true;
}
static bool step3SimplificationTriggerSelfTest()
{
otNNSimplificationPolicy simplificationPolicy;
otNNSimplificationPlan plan;
otNNTopology active;
otNNSimplificationTriggerPolicy policy;
otNNSimplificationTriggerContext context;
otNNSimplificationTriggerReport report;
otNeuralAutonomyController::defaultSimplificationPolicy(simplificationPolicy);
otTinn::makeSingleHiddenTopology(active, 256, 10, 28);
if(!otNeuralAutonomyController::planSimplerTopology(
active, 0UL, simplificationPolicy, plan) || !plan.valid || !plan.changed)
return false;
otNeuralAutonomyController::defaultSimplificationTriggerPolicy(policy);
memset(&context, 0, sizeof(context));
context.autonomyPhase = OTNN_AUTONOMY_ACTIVE_STABLE;
context.monitorState = OTNN_MONITOR_GOOD;
context.stableSamples = policy.minimumStableSamples;
context.activeAgeSamples = policy.minimumActiveAgeSamples;
context.previousAttemptKnown = 0;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
plan, context, policy, report) || !report.valid || !report.eligible ||
report.reason != OTNN_SIMPLIFY_TRIGGER_ELIGIBLE ||
report.parameterReductionRatio < 0.05f ||
strcmp(otNeuralAutonomyController::simplificationTriggerReasonName(report.reason),
"ELIGIBLE") != 0)
return false;
context.stableSamples = policy.minimumStableSamples - 1UL;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
plan, context, policy, report) || report.eligible ||
report.reason != OTNN_SIMPLIFY_TRIGGER_STABILITY_DWELL)
return false;
context.stableSamples = policy.minimumStableSamples;
context.activeAgeSamples = policy.minimumActiveAgeSamples - 1UL;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
plan, context, policy, report) || report.eligible ||
report.reason != OTNN_SIMPLIFY_TRIGGER_ACTIVE_AGE_HOLDOFF)
return false;
context.activeAgeSamples = policy.minimumActiveAgeSamples;
context.previousAttemptKnown = 1;
context.samplesSincePreviousAttempt = policy.cooldownSamples - 1UL;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
plan, context, policy, report) || report.eligible ||
report.reason != OTNN_SIMPLIFY_TRIGGER_COOLDOWN)
return false;
context.samplesSincePreviousAttempt = policy.cooldownSamples;
context.monitorState = OTNN_MONITOR_WARNING;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
plan, context, policy, report) || report.eligible ||
report.reason != OTNN_SIMPLIFY_TRIGGER_MONITOR_UNSTABLE)
return false;
context.monitorState = OTNN_MONITOR_NOTICE;
context.hasPrevious = 1;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
plan, context, policy, report) || report.eligible ||
report.reason != OTNN_SIMPLIFY_TRIGGER_ROLE_BUSY)
return false;
context.hasPrevious = 0;
context.autonomyPhase = OTNN_AUTONOMY_RETRAIN_PENDING;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
plan, context, policy, report) || report.eligible ||
report.reason != OTNN_SIMPLIFY_TRIGGER_PHASE_BUSY)
return false;
context.autonomyPhase = OTNN_AUTONOMY_ACTIVE_STABLE;
policy.minimumParameterReductionRatio = 0.50f;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
plan, context, policy, report) || report.eligible ||
report.reason != OTNN_SIMPLIFY_TRIGGER_SAVINGS_TOO_SMALL)
return false;
return true;
}
static bool step4SimplificationLifecycleSelfTest()
{
otNeuralAutonomyController controller;
otNeuralModelLifecycle lifecycle;
otTinn activeModel;
otTinn candidateModel;
otNNTopology activeTopology;
otNNSimplificationPolicy simplificationPolicy;
otNNSimplificationPlan plan;
otNNModelDescriptor activeD;
otNNModelDescriptor candidateD;
otTinnWarmStartReport warm;
otNeuralAutonomyController::defaultSimplificationPolicy(simplificationPolicy);
otTinn::makeSingleHiddenTopology(activeTopology, 8, 2, 12);
if(!otNeuralAutonomyController::planSimplerTopology(
activeTopology, 0UL, simplificationPolicy, plan) ||
!plan.valid || !plan.changed || plan.topology.hidden[0] != 8)
return false;
if(!activeModel.init(activeTopology, 0)) return false;
otNeuralTrainingSession::makeDescriptor(activeD, 25001UL, 1UL, activeTopology);
if(!lifecycle.attachActive(&activeModel, activeD)) return false;
otNeuralTrainingSession::makeDescriptor(candidateD, 25002UL, 1UL, plan.topology);
if(!lifecycle.prepareCandidate(&candidateModel, candidateD, 0)) return false;
memset(&warm, 0, sizeof(warm));
if(!candidateModel.warmStartFrom(activeModel, warm) ||
warm.mode != OTNN_WARMSTART_STRUCTURED_PRUNE_COPY ||
warm.functionPreserved)
return false;
controller.init(0);
if(!controller.resumeTraining() || controller.phase() != OTNN_AUTONOMY_TRAINING)
return false;
lifecycle.clearCandidate();
candidateModel.close();
if(!controller.actionCompleted(OTNN_AUTONOMY_ACTION_REJECT_CANDIDATE, true) ||
controller.phase() != OTNN_AUTONOMY_RETRAIN_PENDING)
return false;
if(!controller.resumeActiveStable() ||
controller.phase() != OTNN_AUTONOMY_ACTIVE_STABLE ||
!lifecycle.hasActive() || lifecycle.hasCandidate() || lifecycle.hasPrevious())
return false;
lifecycle.reset();
activeModel.close();
return true;
}
/* ------------------------------------------------------------------------- */
/* v0.25 Step 5 accelerated simplification validation (host). */
/* */
/* Real model operations are used: planner -> PRUNE-COPY -> short training */
/* -> checkpoint/reload -> Q15 -> lifecycle persistence/reboot. Quality */
/* evidence is deterministic so this regression tests policy transactions, */
/* not dataset luck. The v025_step5_host_* namespace is disposable. */
/* ------------------------------------------------------------------------- */
static void step5HostCleanupFiles()
{
const char * names[] = {
"v025_step5_host_lifecycle_A.otl", "v025_step5_host_lifecycle_B.otl",
"v025_step5_host_lifecycle_A_active.otm", "v025_step5_host_lifecycle_A_candidate.otm", "v025_step5_host_lifecycle_A_previous.otm",
"v025_step5_host_lifecycle_B_active.otm", "v025_step5_host_lifecycle_B_candidate.otm", "v025_step5_host_lifecycle_B_previous.otm",
"v025_step5_host_accept_A.otm", "v025_step5_host_accept_A.ots", "v025_step5_host_accept_B.otm", "v025_step5_host_accept_B.ots",
"v025_step5_host_reject_A.otm", "v025_step5_host_reject_A.ots", "v025_step5_host_reject_B.otm", "v025_step5_host_reject_B.ots"
};
int i;
for(i = 0; i < (int)(sizeof(names) / sizeof(names[0])); ++i) remove(names[i]);
}
static bool step5HostDecision(otNeuralModelLifecycle & lifecycle,
otNeuralAutonomyController & controller,
float candidateAccuracy,
float candidateError,
float candidateLatencyUs,
int expectPromotion,
int expectedReason)
{
otNNModelDescriptor activeD, candidateD;
otNNValidationReport validation;
otNNExecutionMetrics activeExecution, candidateExecution;
otNNComplexityReport activeComplexity, candidateComplexity;
otNNComparisonPolicy comparisonPolicy;
otNNComparisonReport comparison;
otNNMeaningfulImprovementPolicy improvementPolicy;
otNNMeaningfulImprovementReport improvement;
otNNDominancePolicy dominancePolicy;
otNNDominanceReport dominance;
otNNComplexityGatePolicy complexityPolicy;
otNNPromotionGateReport gates;
otNNPromotionDecisionTrace trace;
otNNShadowReport shadow;
otNNPromotionReport promotion;
otTinnQ15MemoryInfo activeQ15, candidateQ15;
int action;
if(!lifecycle.activeDescriptor(activeD) || !lifecycle.candidateDescriptor(candidateD) ||
lifecycle.activeModel() == 0 || lifecycle.candidateModel() == 0) return false;
if(!lifecycle.activeModel()->prepareQ15() || !lifecycle.candidateModel()->prepareQ15()) return false;
memset(&activeExecution, 0, sizeof(activeExecution));
memset(&candidateExecution, 0, sizeof(candidateExecution));
activeExecution.q15LatencyValid = 1;
activeExecution.q15LatencyUs = 10.0f;
candidateExecution.q15LatencyValid = 1;
candidateExecution.q15LatencyUs = candidateLatencyUs;
if(!otNeuralModelLifecycle::buildComplexityReport(lifecycle.activeModel(), activeD,
&activeExecution, activeComplexity) ||
!otNeuralModelLifecycle::buildComplexityReport(lifecycle.candidateModel(), candidateD,
&candidateExecution, candidateComplexity)) return false;
lifecycle.activeModel()->q15MemoryInfo(activeQ15);
lifecycle.candidateModel()->q15MemoryInfo(candidateQ15);
memset(&validation, 0, sizeof(validation));
validation.valid = 1;
validation.sampleCount = 400;
validation.active.valid = validation.candidate.valid = 1;
validation.active.samples = validation.candidate.samples = 400UL;
validation.active.classificationAvailable = validation.candidate.classificationAvailable = 1;
validation.active.accuracyPercent = 90.0f;
validation.candidate.accuracyPercent = candidateAccuracy;
validation.active.meanAbsError = 0.100f;
validation.candidate.meanAbsError = candidateError;
validation.active.parameterCount = activeComplexity.parameters;
validation.candidate.parameterCount = candidateComplexity.parameters;
validation.active.q15Prepared = validation.candidate.q15Prepared = 1;
validation.active.q15Evaluated = validation.candidate.q15Evaluated = 1;
validation.active.q15AccuracyPercent = 90.0f;
validation.candidate.q15AccuracyPercent = candidateAccuracy;
validation.active.q15MeanAbsError = 0.100f;
validation.candidate.q15MeanAbsError = candidateError;
validation.active.q15Memory = activeQ15;
validation.candidate.q15Memory = candidateQ15;
otNeuralModelLifecycle::defaultComparisonPolicy(comparisonPolicy);
otNeuralModelLifecycle::defaultMeaningfulImprovementPolicy(improvementPolicy);
otNeuralModelLifecycle::defaultDominancePolicy(dominancePolicy);
if(!otNeuralModelLifecycle::evaluateMeaningfulImprovement(validation, improvementPolicy, improvement)) return false;
if(!lifecycle.compareCandidate(validation, activeExecution, candidateExecution,
comparisonPolicy, comparison)) return false;
if(!otNeuralModelLifecycle::evaluateDominance(comparison, improvement,
activeComplexity, candidateComplexity, dominancePolicy, dominance)) return false;
controller.init(0);
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
controller.setComplexityGatePolicy(&complexityPolicy);
controller.setOperatingWindow(OTNN_WINDOW_MAINTENANCE);
if(!controller.resumeTraining()) return false;
action = controller.nextAction(lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_VALIDATE_CANDIDATE ||
!controller.actionCompleted(action, true)) return false;
if(!controller.evaluatePromotionGates(validation, candidateExecution,
&candidateComplexity, &dominance, 0, gates)) return false;
if(!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, 0, trace)) return false;
if(expectPromotion)
{
if(trace.reason != OTNN_DECISION_WAIT_SHADOW || trace.finalDecisionKnown) return false;
action = controller.nextAction(lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_SHADOW_CANDIDATE ||
!controller.actionCompleted(action, true)) return false;
memset(&shadow, 0, sizeof(shadow));
shadow.valid = 1;
shadow.activeExecutedFirst = 1;
shadow.candidateAuthority = 0;
shadow.samples = 400UL;
if(!controller.evaluatePromotionGates(validation, candidateExecution,
&candidateComplexity, &dominance, &shadow, gates)) return false;
if(!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, &shadow, trace)) return false;
if(!trace.finalDecisionKnown || !trace.eligible || trace.reason != expectedReason) return false;
action = controller.nextAction(lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_PROMOTE_CANDIDATE) return false;
memset(&promotion, 0, sizeof(promotion));
if(!lifecycle.promoteCandidate(promotion) || !controller.actionCompleted(action, true)) return false;
return controller.phase() == OTNN_AUTONOMY_PROBATION && lifecycle.hasPrevious();
}
if(!trace.finalDecisionKnown || trace.eligible || trace.reason != expectedReason)
{
printf(" Step 5 reject decision observed=%s expected=%s final=%d eligible=%d\n",
otNeuralAutonomyController::promotionDecisionReasonName(trace.reason),
otNeuralAutonomyController::promotionDecisionReasonName(expectedReason),
trace.finalDecisionKnown, trace.eligible);
return false;
}
action = controller.nextAction(lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_REJECT_CANDIDATE) return false;
lifecycle.clearCandidate();
if(!controller.actionCompleted(action, true)) return false;
return controller.resumeActiveStable() && controller.phase() == OTNN_AUTONOMY_ACTIVE_STABLE;
}
static bool step5AcceleratedSimplificationSelfTest()
{
otTinn model0, model1, model2;
otNeuralModelLifecycle lifecycle;
otNeuralLifecycleStorage storage;
otNNLifecycleCatalogReport catalog;
otNeuralAutonomyController controller;
otNNSimplificationPolicy simplificationPolicy;
otNNSimplificationPlan plan;
otNNSimplificationTriggerPolicy triggerPolicy;
otNNSimplificationTriggerContext triggerContext;
otNNSimplificationTriggerReport triggerReport;
otNNModelDescriptor activeD, candidateD, restoredD;
otTinnWarmStartReport warm;
otNNTopology activeTopology;
int action;
printf("v0.25 Step 5 accelerated simplification validation: START\n");
step5HostCleanupFiles();
storage.init(0);
if(!model0.load("saved.tinn")) goto fail;
model0.topology(activeTopology);
otNeuralTrainingSession::makeDescriptor(activeD, 92500UL, 1UL, activeTopology);
if(!lifecycle.attachActive(&model0, activeD)) goto fail;
if(!storage.saveSnapshot("v025_step5_host_lifecycle", lifecycle, catalog)) goto fail;
/* A: a real smaller Candidate survives train/checkpoint/Q15, is promoted,
committed, restored after a simulated reboot and completes probation. */
otNeuralAutonomyController::defaultSimplificationPolicy(simplificationPolicy);
if(!otNeuralAutonomyController::planSimplerTopology(activeTopology, 0UL,
simplificationPolicy, plan) || !plan.valid || !plan.changed ||
plan.topology.hiddenLayers != 1 || plan.topology.hidden[0] != 24) goto fail;
otNeuralTrainingSession::makeDescriptor(candidateD, 92501UL, 1UL, plan.topology);
if(!lifecycle.prepareCandidate(&model1, candidateD, 0)) goto fail;
memset(&warm, 0, sizeof(warm));
if(!model1.warmStartFrom(model0, warm) ||
warm.mode != OTNN_WARMSTART_STRUCTURED_PRUNE_COPY || warm.functionPreserved) goto fail;
if(!step10HostTrainCheckpointReload(&model1, candidateD, "v025_step5_host_accept")) goto fail;
if(!model1.prepareQ15()) goto fail;
if(!storage.saveSnapshot("v025_step5_host_lifecycle", lifecycle, catalog)) goto fail;
if(!step5HostDecision(lifecycle, controller, 90.0f, 0.100f, 8.0f, 1,
OTNN_DECISION_PROMOTE_PARETO)) goto fail;
if(!storage.saveSnapshot("v025_step5_host_lifecycle", lifecycle, catalog)) goto fail;
lifecycle.reset(); model0.close(); model1.close(); model2.close();
if(!storage.loadLatestSnapshot("v025_step5_host_lifecycle", lifecycle,
&model0, &model1, &model2, catalog)) goto fail;
if(!lifecycle.activeDescriptor(restoredD) || restoredD.topology.hidden[0] != 24 ||
!lifecycle.hasPrevious() || lifecycle.hasCandidate()) goto fail;
if(lifecycle.activeModel() == 0 || !lifecycle.activeModel()->prepareQ15()) goto fail;
controller.init(0);
if(!controller.resumeProbation() || !controller.acceptProbation()) goto fail;
if(!lifecycle.retirePrevious()) goto fail;
model2.close();
if(!storage.saveSnapshot("v025_step5_host_lifecycle", lifecycle, catalog)) goto fail;
controller.markCatalogCommitted();
printf(" accept/persist/reboot/probation : 256-28-10 -> 256-24-10 PASS\n");
/* B: another real shrink is trained/Q15-ready but loses the quality-cost
tradeoff. ACTIVE is preserved and a cooldown blocks immediate retry. */
if(!lifecycle.activeDescriptor(activeD)) goto fail;
if(!otNeuralAutonomyController::planSimplerTopology(activeD.topology, 0UL,
simplificationPolicy, plan) || !plan.valid || !plan.changed) goto fail;
otNeuralTrainingSession::makeDescriptor(candidateD, 92502UL, 1UL, plan.topology);
if(!lifecycle.prepareCandidate(&model1, candidateD, 0)) goto fail;
memset(&warm, 0, sizeof(warm));
if(!model1.warmStartFrom(*lifecycle.activeModel(), warm) ||
warm.mode != OTNN_WARMSTART_STRUCTURED_PRUNE_COPY) goto fail;
if(!step10HostTrainCheckpointReload(&model1, candidateD, "v025_step5_host_reject")) goto fail;
if(!model1.prepareQ15()) goto fail;
if(!step5HostDecision(lifecycle, controller, 87.0f, 0.140f, 7.0f, 0,
OTNN_DECISION_REJECT_FLOAT_QUALITY)) goto fail;
model1.close();
if(!lifecycle.activeDescriptor(restoredD) || restoredD.modelId != activeD.modelId ||
lifecycle.hasCandidate() || lifecycle.hasPrevious()) goto fail;
otNeuralAutonomyController::defaultSimplificationTriggerPolicy(triggerPolicy);
memset(&triggerContext, 0, sizeof(triggerContext));
triggerContext.autonomyPhase = OTNN_AUTONOMY_ACTIVE_STABLE;
triggerContext.monitorState = OTNN_MONITOR_GOOD;
triggerContext.stableSamples = triggerPolicy.minimumStableSamples;
triggerContext.activeAgeSamples = triggerPolicy.minimumActiveAgeSamples;
triggerContext.previousAttemptKnown = 1;
triggerContext.samplesSincePreviousAttempt = triggerPolicy.cooldownSamples - 1UL;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(plan, triggerContext,
triggerPolicy, triggerReport) || triggerReport.eligible ||
triggerReport.reason != OTNN_SIMPLIFY_TRIGGER_COOLDOWN) goto fail;
if(!storage.saveSnapshot("v025_step5_host_lifecycle", lifecycle, catalog)) goto fail;
printf(" reject + neutral cooldown : ACTIVE preserved PASS\n");
/* C: degradation preempts an in-flight simplification and immediately
hands control back to the normal retrain chain. */
if(!lifecycle.activeDescriptor(activeD)) goto fail;
if(!otNeuralAutonomyController::planSimplerTopology(activeD.topology, 0UL,
simplificationPolicy, plan) || !plan.valid || !plan.changed) goto fail;
otNeuralTrainingSession::makeDescriptor(candidateD, 92503UL, 1UL, plan.topology);
if(!lifecycle.prepareCandidate(&model1, candidateD, 0)) goto fail;
memset(&warm, 0, sizeof(warm));
if(!model1.warmStartFrom(*lifecycle.activeModel(), warm)) goto fail;
controller.init(0);
controller.setOperatingWindow(OTNN_WINDOW_MAINTENANCE);
if(!controller.resumeTraining()) goto fail;
if(!(OTNN_MONITOR_WARNING > triggerPolicy.maximumMonitorState)) goto fail;
lifecycle.clearCandidate(); model1.close();
if(!controller.actionCompleted(OTNN_AUTONOMY_ACTION_REJECT_CANDIDATE, true) ||
!controller.resumeActiveStable()) goto fail;
controller.observeMonitorState(OTNN_MONITOR_RETRAIN_REQUIRED);
action = controller.nextAction(lifecycle, OTNN_TRAINING_EMPTY);
if(action != OTNN_AUTONOMY_ACTION_CREATE_CANDIDATE) goto fail;
printf(" monitor preemption -> retrain : PASS\n");
lifecycle.reset(); model0.close(); model1.close(); model2.close();
step5HostCleanupFiles();
printf("v0.25 Step 5 accelerated simplification validation: PASS\n");
return true;
fail:
lifecycle.reset(); model0.close(); model1.close(); model2.close();
step5HostCleanupFiles();
printf("v0.25 Step 5 accelerated simplification validation: FAIL\n");
return false;
}
static bool modelPerformanceSignatureSelfTest()
{
otNNModelDescriptor descriptor;
otNNValidationMetrics validation;
otNNComplexityReport complexity;
otTinnQ15MemoryInfo deploymentMemory;
otNNModelPerformanceSignature signature;
memset(&descriptor, 0, sizeof(descriptor));
memset(&validation, 0, sizeof(validation));
memset(&complexity, 0, sizeof(complexity));
memset(&deploymentMemory, 0, sizeof(deploymentMemory));
memset(&signature, 0, sizeof(signature));
descriptor.modelId = 42UL;
descriptor.revision = 3UL;
descriptor.topology.inputs = 8;
descriptor.topology.hiddenLayers = 1;
descriptor.topology.hidden[0] = 4;
descriptor.topology.outputs = 2;
validation.valid = 1;
validation.classificationAvailable = 1;
validation.samples = 100UL;
validation.accuracyPercent = 97.0f;
validation.meanAbsError = 0.025f;
validation.maxAbsError = 0.125f;
validation.parameterCount = 42UL;
validation.q15Prepared = 1;
validation.q15Evaluated = 1;
validation.q15AccuracyPercent = 96.0f;
validation.q15MeanAbsError = 0.030f;
validation.q15MaxAbsError = 0.140f;
complexity.valid = 1;
complexity.hiddenLayers = 1;
complexity.maxHiddenWidth = 4;
complexity.parameters = 42UL;
complexity.macsPerInference = 40UL;
complexity.floatParameterBytes = 168UL;
complexity.floatRuntimeBytes = 224UL;
complexity.trainingWorkspaceBytes = 24UL;
complexity.q15Ready = 1;
complexity.q15RuntimeBytes = 100UL;
complexity.q15FastBytes = 20UL; /* shadow snapshot: deliberately different */
complexity.q15NormalBytes = 80UL;
complexity.q15MemoryMode = OTNN_Q15_MEMORY_MIXED;
complexity.q15LatencyValid = 1;
complexity.q15LatencyUs = 12.5f;
deploymentMemory.ready = 1;
deploymentMemory.totalBytes = 100UL;
deploymentMemory.fastBytes = 100UL;
deploymentMemory.normalBytes = 0UL;
deploymentMemory.mode = OTNN_Q15_MEMORY_FAST;
if(!otNeuralModelLifecycle::buildModelPerformanceSignature(
descriptor, validation, complexity, &deploymentMemory,
1, 48000UL, 24000UL, signature))
return false;
if(!signature.valid ||
signature.modelId != 42UL ||
signature.parameters != 42UL ||
signature.q15FastBytes != 100UL ||
signature.q15NormalBytes != 0UL ||
signature.q15MemoryMode != OTNN_Q15_MEMORY_FAST ||
!signature.q15DeploymentMemoryOverrideUsed ||
!signature.deploymentLatencyValid ||
signature.deploymentLatencyUs != 12.5f ||
!signature.lifecycleAvailable ||
signature.activeAgeSamples != 48000UL ||
signature.stableSamples != 24000UL)
return false;
printf("v0.25 Model Performance Signature self-test: PASS\n");
return true;
}
int main()
{
const bool pass = topologyStep11CoreSelfTest();
const bool signature = pass ? modelPerformanceSignatureSelfTest() : false;
const bool decisionPath = (pass && signature) ? step7DeterministicDecisionPathSelfTest(0) : false;
const bool simplificationTrigger = (pass && signature && decisionPath) ? step3SimplificationTriggerSelfTest() : false;
const bool simplificationLifecycle = (pass && decisionPath && simplificationTrigger) ?
step4SimplificationLifecycleSelfTest() : false;
const bool simplificationAccelerated = (pass && decisionPath && simplificationTrigger && simplificationLifecycle) ?
step5AcceleratedSimplificationSelfTest() : false;
const bool accelerated = (pass && decisionPath && simplificationTrigger && simplificationLifecycle && simplificationAccelerated) ?
step10AcceleratedLifecycleSelfTest() : false;
printf("otTINN v0.25 CONSOLIDATED R3 - Full Host Regression Validation\n");
printf("generic float/Q15 core : 1..4 hidden layers preserved\n");
printf("architecture planner : deterministic, resource + outcome aware\n");
printf("outcome memory : 10-stage attempted mask + 2-bit outcome/stage\n");
printf("candidate initialization : clone / function-preserving widen / structured PRUNE-COPY / fresh-depth\n");
printf("complexity report : parameters/MACs/float/Q15/workspace/topology/latency; no score\n");
printf("model performance signature : policy interface identity/quality/complexity/resources/lifecycle; no score\n");
printf("complexity gates : absolute independent limits; no ACTIVE comparison\n");
printf("meaningful improvement : independent thresholds; feeds dominance promotion gate\n");
printf("dominance promotion gate : Candidate Pareto OR meaningful bounded-cost tradeoff\n");
printf("decision logging : explicit reason + independent quality/cost deltas; observational only\n");
printf("decision-path regression : 4 deterministic VALIDATE/SHADOW/PROMOTE/REJECT cases\n");
printf("simplification planner : deepest-first one-quantum narrowing, then deepest-layer removal\n");
printf("structured prune-copy : same-depth shrink keeps strongest outgoing-weight neurons; deterministic, not exact\n");
printf("simplification trigger : stable dwell + active-age holdoff + cooldown + minimum savings; autonomous\n");
printf("simplification lifecycle : trigger -> smaller Candidate -> PRUNE-COPY/FRESH -> normal train/validate/shadow/dominance\n");
printf("simplification failure semantics : reject/rollback returns ACTIVE_STABLE; architecture outcome memory untouched\n");
printf("simplification outcome memory : production BF518 SIMMEM1 blocks exact rejected shrink per ACTIVE (host policy branch unchanged)\n");
printf("simplification accelerated test : accept+persistence+reboot+probation / reject+cooldown / monitor preemption\n");
printf("accelerated validation : stage2 widen + stage4 depth + checkpoint/Q15/persist/promote/rollback\n");
printf("v0.25 consolidated full regression: %s\n",
(pass && signature && decisionPath && simplificationTrigger && simplificationLifecycle && simplificationAccelerated) ? "PASS" : "FAIL");
printf("v0.23 inherited accelerated regression: %s\n", accelerated ? "PASS" : "FAIL");
return (pass && signature && decisionPath && simplificationTrigger && simplificationLifecycle && simplificationAccelerated && accelerated) ? 0 : 1;
}
#else
#include "main.h"
#include <otSerial.h>
#include <otMalloc.h>
#include <otPrintf.h>
#include <otFILE.h>
#include <otTimer.h>
#include <otRTC.h>
#include <otNeuralNetwork.h>
#include "otNeuralScenario.h"
#include "otNeuralMonitor.h"
#include "otNeuralTraining.h"
#include "otNeuralModelLifecycle.h"
#include "otNeuralLifecycleStorage.h"
#include "otNeuralAutonomy.h"
#include <string.h>
#define END_INPUTS 256
#define END_OUTPUTS 10
#define END_BOOTSTRAP_HIDDEN 28
#define END_SOURCE_DATASET "semeion_bench.data"
#define END_BOOTSTRAP_MODEL "saved.tinn"
#define END_LIFECYCLE_PREFIX "v022_endurance_lifecycle"
#define END_TRAINING_PREFIX "v022_endurance_training"
#define END_TRAIN_DATASET "v022_endurance_train.data"
#define END_VALIDATION_DATASET "v022_endurance_validation.data"
#define END_LOG_FILE "v022_endurance.log"
#define END_STATE_A "v022_endurance_state_A.txt"
#define END_STATE_B "v022_endurance_state_B.txt"
#define END_STATE_LINE_BUFFER_SIZE 512UL
#define END_WORLD_BASE_SEED 0xE21D2026UL
#define END_WORLD_CYCLE_SAMPLES 12000UL
/* Calm-tail laboratory hook retained for reproducibility but DISABLED in
* production R2. The normal deterministic aggressive world is active again.
* No lifecycle threshold or policy is changed by Model Signature Step 1.
*/
#define END_CALM_TAIL_ENABLED 0
#define END_CALM_TAIL_START_CYCLE 8UL
#define END_TELEMETRY_PERIOD 250UL
#define END_STATE_SAVE_PERIOD 1000UL
#define END_LOG_SYNC_PERIOD 1000UL
#define END_TRAIN_EPOCHS 8UL
#define END_TRAIN_BLOCK_SAMPLES 8UL
#define END_CHECKPOINT_PERIOD 128UL
#define END_PROBATION_GOOD_SAMPLES 1000UL
#define END_RETRY_COOLDOWN_SAMPLES 2000UL
#define END_LATENCY_ITERATIONS 100UL
#define END_DEGRADED_RETRAIN_EVALS 32UL /* 32 x 32 = ~1024 persistent samples */
/* ========================================================================
* TOPPA HARDWARE BF518 - deployment-latency normalization
*
* This is NOT neural-policy logic. It compensates for a physical limitation
* of this target: ACTIVE and CANDIDATE cannot simultaneously obtain equivalent
* residence in the scarce fast Q15 memory banks. During normal shadow ACTIVE
* correctly owns FAST first, so CANDIDATE can spill to slower memory and appear
* ~3x slower even when it has the same topology.
*
* For promotion/dominance only, R2 therefore measures a temporary
* "as-if-promoted" CANDIDATE latency: ACTIVE/CANDIDATE Q15 runtimes are released,
* CANDIDATE is prepared alone and timed, then ACTIVE is rebuilt FIRST and
* CANDIDATE SECOND to restore the real shadow state. No Candidate actuation is
* ever enabled by this patch. Remove/replace this workaround on hardware where
* ACTIVE and CANDIDATE can be benchmarked with equivalent memory residency.
* ======================================================================== */
#define END_BF518_DEPLOYMENT_LATENCY_PATCH 1
/* v0.23 Step 10 isolated accelerated validation. These prefixes never touch
* the production endurance lifecycle/state/checkpoint namespace. */
#define STEP10_LIFECYCLE_PREFIX "v023_step10_validation_lifecycle"
#define STEP10_WIDE_TRAIN_PREFIX "v023_step10_validation_wide"
#define STEP10_DEEP_TRAIN_PREFIX "v023_step10_validation_deep"
#define STEP10_TRAIN_SAMPLES 32UL
/* v0.25 Step 5 isolated accelerated simplification validation. */
#define STEP5_LIFECYCLE_PREFIX "v025_step5_validation_lifecycle"
#define STEP5_ACCEPT_TRAIN_PREFIX "v025_step5_validation_accept"
#define STEP5_REJECT_TRAIN_PREFIX "v025_step5_validation_reject"
/* Production default: do not run the accelerated Stage2/Stage4 regression on
* every BF518 boot. Set to 1 for an explicit regression build. The regression
* namespace is isolated from v022_endurance_* and exact heap cleanup remains
* part of its PASS criterion. */
#ifndef OTTINN_RUN_BOOT_REGRESSION
#define OTTINN_RUN_BOOT_REGRESSION 0
#endif
/* Heavy deterministic policy/simplification regressions validated on the real
* BF518 are retained for diagnostics but disabled during normal long runs. */
#ifndef OTTINN_RUN_POLICY_REGRESSION
#define OTTINN_RUN_POLICY_REGRESSION 0
#endif
/* RTC is initialized to the user's requested reference only when it is clearly
* uninitialized/older. Once the RTC is running (for example from backup power),
* later boots preserve real elapsed wall-clock time. */
#define END_RTC_REFERENCE_YEAR 2026
#define END_RTC_REFERENCE_MONTH 9
#define END_RTC_REFERENCE_DAY 21
#define END_RTC_REFERENCE_HOUR 12
#define END_RTC_REFERENCE_MINUTE 0
#define END_RTC_REFERENCE_SECOND 0
#ifndef END_BENCH_TIMER
#define END_BENCH_TIMER TIMER7
#endif
/* ------------------------------------------------------------------------- */
/* Persistent objects: never put these on the 4 KiB BF518 stack. */
/* ------------------------------------------------------------------------- */
otFILE file;
SDRAM_DATA otNeuralLifecycleStorage g_storage;
SDRAM_DATA otNeuralModelLifecycle g_lifecycle;
SDRAM_DATA otTinn g_model0;
SDRAM_DATA otTinn g_model1;
SDRAM_DATA otTinn g_model2;
SDRAM_DATA otNNLifecycleCatalogReport g_catalogReport;
SDRAM_DATA otNeuralFramework g_sourceFramework;
SDRAM_DATA otNeuralFramework g_trainFramework;
SDRAM_DATA otNeuralFramework g_validationFramework;
SDRAM_DATA otNeuralTrainingSession g_trainingSession;
SDRAM_DATA otNeuralScenario g_world;
SDRAM_DATA otNeuralMonitor g_monitor;
FAST_DATA_2 otNeuralAutonomyController g_controller;
FAST_DATA_2 otNNPromotionGateReport g_gateReport;
FAST_DATA_2 otNNValidationReport g_validationReport;
FAST_DATA_2 otNNShadowReport g_shadowReport;
FAST_DATA_2 otNNPromotionReport g_promotionReport;
FAST_DATA_2 otNNRollbackReport g_rollbackReport;
FAST_DATA_2 otNNExecutionMetrics g_activeExecution;
FAST_DATA_2 otNNExecutionMetrics g_candidateExecution;
FAST_DATA_2 otNNComplexityReport g_activeComplexity;
FAST_DATA_2 otNNComplexityReport g_candidateComplexity;
FAST_DATA_2 otNNModelPerformanceSignature g_activeSignature;
FAST_DATA_2 otNNModelPerformanceSignature g_candidateSignature;
FAST_DATA_2 otNNMeaningfulImprovementPolicy g_improvementPolicy;
FAST_DATA_2 otNNMeaningfulImprovementReport g_improvementReport;
FAST_DATA_2 otNNComparisonPolicy g_comparisonPolicy;
FAST_DATA_2 otNNComparisonReport g_comparisonReport;
FAST_DATA_2 otNNDominancePolicy g_dominancePolicy;
FAST_DATA_2 otNNDominanceReport g_dominanceReport;
FAST_DATA_2 otNNPromotionDecisionTrace g_decisionTrace;
FAST_DATA_2 otNNArchitecturePolicy g_architecturePolicy;
FAST_DATA_2 otNNSimplificationPolicy g_simplificationPolicy;
FAST_DATA_2 otNNSimplificationTriggerPolicy g_simplificationTriggerPolicy;
FAST_DATA_2 otNNSimplificationPlan g_simplificationPlan;
FAST_DATA_2 otNNSimplificationTriggerContext g_simplificationTriggerContext;
FAST_DATA_2 otNNSimplificationTriggerReport g_simplificationTriggerReport;
FAST_DATA_2 int g_previousSimplificationTriggerReason = -1;
enum SimplificationBlockedOutcome
{
SIMPLIFY_BLOCK_NONE = 0,
SIMPLIFY_BLOCK_REJECT = 1,
SIMPLIFY_BLOCK_ROLLBACK = 2
};
/* R2 BF518 hardware-patch diagnostics. Kept in SDRAM so the workaround itself
* does not consume scarce L1/L2 data or the 4 KiB application stack. */
SDRAM_DATA otTinnQ15MemoryInfo g_r2ActiveShadowQ15;
SDRAM_DATA otTinnQ15MemoryInfo g_r2CandidateShadowQ15;
SDRAM_DATA otTinnQ15MemoryInfo g_r2CandidateDeploymentQ15;
SDRAM_DATA otTinnQ15MemoryInfo g_r2ActiveRestoredQ15;
SDRAM_DATA otTinnQ15MemoryInfo g_r2CandidateRestoredQ15;
/* v0.25 Step 1 planner self-test state is cold and must not consume the
* 4 KiB stack or scarce L1 DATA_A. Keep it in SDRAM like the Step 7 harness. */
SDRAM_DATA otNNSimplificationPolicy g_v025SimplificationPolicy;
SDRAM_DATA otNNSimplificationPlan g_v025SimplificationPlan;
SDRAM_DATA otNNTopology g_v025SimplificationActive;
/* v0.25 Step 3 trigger-policy self-test state. Keep cold test state in SDRAM. */
SDRAM_DATA otNNSimplificationTriggerPolicy g_v025TriggerPolicy;
SDRAM_DATA otNNSimplificationTriggerContext g_v025TriggerContext;
SDRAM_DATA otNNSimplificationTriggerReport g_v025TriggerReport;
SDRAM_DATA float g_worldInput[END_INPUTS];
SDRAM_DATA float g_worldTarget[END_OUTPUTS];
SDRAM_DATA float g_predictionFloat[END_OUTPUTS];
SDRAM_DATA short g_qInput[END_INPUTS];
SDRAM_DATA char g_enduranceStateLine[END_STATE_LINE_BUFFER_SIZE];
SDRAM_DATA FILE g_logFile = 0;
struct EnduranceState
{
unsigned long valid;
unsigned long sequence;
unsigned long tickHi;
unsigned long tickLo;
unsigned long worldCycle;
unsigned long worldLocalTick;
unsigned long nextModelId;
unsigned long architectureFailures;
unsigned long architectureNextStage;
unsigned long architectureParameterCeiling;
unsigned long adaptationArchitectureStage;
unsigned long architectureSaturated;
unsigned long architectureAttemptedMask;
unsigned long architectureOutcomeBits;
/* v0.25 Step 4 persistent anti-oscillation + transaction state.
mode: 0=none, 1=Candidate/training, 2=promoted/probation. */
unsigned long simplificationStableSamples;
unsigned long simplificationActiveAgeSamples;
unsigned long simplificationPreviousAttemptKnown;
unsigned long simplificationSamplesSinceAttempt;
unsigned long simplificationLifecycleMode;
unsigned long simplificationAttempts;
unsigned long simplificationPromotions;
unsigned long simplificationRejections;
unsigned long simplificationRollbacks;
/* v0.25 R2 SIMMEM1: one-entry outcome memory for the deterministic
immediate shrink target of the current ACTIVE. A reject or probation
rollback records the exact parent modelId + target topology. While that
ACTIVE remains authoritative, the same target is not hammered again.
A genuine ACTIVE role change clears this memory. */
unsigned long simplificationBlockedParentModelId;
unsigned long simplificationBlockedTargetInputs;
unsigned long simplificationBlockedTargetOutputs;
unsigned long simplificationBlockedTargetHiddenLayers;
unsigned long simplificationBlockedTargetHidden0;
unsigned long simplificationBlockedTargetHidden1;
unsigned long simplificationBlockedTargetHidden2;
unsigned long simplificationBlockedTargetHidden3;
unsigned long simplificationBlockedOutcome; /* 0=none, 1=reject, 2=rollback */
unsigned long checksum;
};
FAST_DATA_2 EnduranceState g_state;
FAST_DATA_2 unsigned long g_lastStateSaveTickLo = 0UL;
FAST_DATA_2 unsigned long g_lastLogSyncTickLo = 0UL;
FAST_DATA_2 unsigned long g_lastCheckpointSamples = 0UL;
FAST_DATA_2 unsigned long g_probationGoodSamples = 0UL;
FAST_DATA_2 unsigned long g_retryCooldown = 0UL;
FAST_DATA_2 int g_previousMonitorState = -1;
FAST_DATA_2 int g_previousWindow = -1;
FAST_DATA_2 int g_stopped = 0;
FAST_DATA_2 int g_rtcWasInitialized = 0;
FAST_DATA_2 unsigned long g_promotionsTotal = 0UL;
FAST_DATA_2 unsigned long g_rollbacksTotal = 0UL;
FAST_DATA_2 unsigned long g_rejectionsTotal = 0UL;
FAST_DATA_2 unsigned long g_checkpointsTotal = 0UL;
/* BOOTFIX1: persistent-state restore diagnostics. Tiny scalar state only. */
FAST_DATA_2 unsigned long g_stateAExists = 0UL;
FAST_DATA_2 unsigned long g_stateBExists = 0UL;
FAST_DATA_2 unsigned long g_stateAValid = 0UL;
FAST_DATA_2 unsigned long g_stateBValid = 0UL;
FAST_DATA_2 unsigned long g_stateAVersion = 0UL;
FAST_DATA_2 unsigned long g_stateBVersion = 0UL;
FAST_DATA_2 unsigned long g_stateASequence = 0UL;
FAST_DATA_2 unsigned long g_stateBSequence = 0UL;
FAST_DATA_2 unsigned long g_stateSelectedSlot = 0UL; /* 0=fresh, 1=A, 2=B */
FAST_DATA_2 unsigned long g_enduranceStateRestored = 0UL;
FAST_DATA_2 unsigned long g_lifecycleRestoredFromCatalog = 0UL;
/* Step 10 validation objects are persistent/global because BF518 has only 4 KiB stack.
* Their heap-backed contents are closed before the normal endurance bootstrap. */
/* v0.24 Step 7 deterministic regression workspace.
* Cold test-only state deliberately lives in SDRAM, not L1/L2 data.
* These are file-scope objects (not function-local static), avoiding the
* GCC __cxa_guard_* runtime that is not provided by the BF518 build. */
SDRAM_DATA otTinn g_step7ActiveModel;
SDRAM_DATA otTinn g_step7CandidateModel;
SDRAM_DATA otNeuralModelLifecycle g_step7Lifecycle;
SDRAM_DATA otNeuralAutonomyController g_step7Controller;
SDRAM_DATA otNNModelDescriptor g_step7ActiveD;
SDRAM_DATA otNNModelDescriptor g_step7CandidateD;
SDRAM_DATA otNNModelDescriptor g_step7AfterD;
SDRAM_DATA otNNTopology g_step7ActiveTopology;
SDRAM_DATA otNNTopology g_step7CandidateTopology;
SDRAM_DATA otNNValidationReport g_step7Validation;
SDRAM_DATA otNNExecutionMetrics g_step7ActiveExecution;
SDRAM_DATA otNNExecutionMetrics g_step7CandidateExecution;
SDRAM_DATA otNNComplexityReport g_step7ActiveComplexity;
SDRAM_DATA otNNComplexityReport g_step7CandidateComplexity;
SDRAM_DATA otNNComparisonPolicy g_step7ComparisonPolicy;
SDRAM_DATA otNNComparisonReport g_step7Comparison;
SDRAM_DATA otNNMeaningfulImprovementPolicy g_step7ImprovementPolicy;
SDRAM_DATA otNNMeaningfulImprovementReport g_step7Improvement;
SDRAM_DATA otNNDominancePolicy g_step7DominancePolicy;
SDRAM_DATA otNNDominanceReport g_step7Dominance;
SDRAM_DATA otNNComplexityGatePolicy g_step7ComplexityPolicy;
SDRAM_DATA otNNPromotionGateReport g_step7Gates;
SDRAM_DATA otNNPromotionDecisionTrace g_step7Trace;
SDRAM_DATA otNNShadowReport g_step7Shadow;
SDRAM_DATA otNNPromotionReport g_step7Promotion;
SDRAM_DATA otTinnQ15MemoryInfo g_step7ActiveQ15;
SDRAM_DATA otTinnQ15MemoryInfo g_step7CandidateQ15;
SDRAM_DATA otNeuralLifecycleStorage g_step10Storage;
SDRAM_DATA otNeuralModelLifecycle g_step10Lifecycle;
SDRAM_DATA otTinn g_step10Model0;
SDRAM_DATA otTinn g_step10Model1;
SDRAM_DATA otTinn g_step10Model2;
SDRAM_DATA otNeuralFramework g_step10Framework;
SDRAM_DATA otNeuralTrainingSession g_step10Training;
FAST_DATA_2 otNNLifecycleCatalogReport g_step10Catalog;
FAST_DATA_2 otNNArchitecturePolicy g_step10ArchPolicy;
FAST_DATA_2 otNNArchitecturePlan g_step10ArchPlan;
FAST_DATA_2 otTinnWarmStartReport g_step10Warm;
FAST_DATA_2 otNNPromotionReport g_step10Promotion;
FAST_DATA_2 otNNRollbackReport g_step10Rollback;
FAST_DATA_2 otNNModelDescriptor g_step10ActiveD;
FAST_DATA_2 otNNModelDescriptor g_step10CandidateD;
FAST_DATA_2 otNNModelDescriptor g_step10RestoredD;
/* World-cycle parameters are logged so a session can be replayed exactly. */
FAST_DATA_2 unsigned long g_worldSeed = END_WORLD_BASE_SEED;
FAST_DATA_2 float g_worldGain = 1.0f;
FAST_DATA_2 float g_worldOffset = 0.0f;
FAST_DATA_2 float g_worldNoise = 0.0f;
FAST_DATA_2 int g_worldPairs[10];
/* ------------------------------------------------------------------------- */
/* Small utilities */
/* ------------------------------------------------------------------------- */
static unsigned long mix32(unsigned long x)
{
x ^= x >> 16;
x *= 0x7FEB352DUL;
x ^= x >> 15;
x *= 0x846CA68BUL;
x ^= x >> 16;
return x;
}
static unsigned long nextRandom(unsigned long & state)
{
state = state * 1664525UL + 1013904223UL;
return state;
}
FAST_CODE_2 static unsigned long stateChecksumV1(const EnduranceState & s)
{
unsigned long h = 2166136261UL;
#define END_HASH(v) do { h ^= (unsigned long)(v); h *= 16777619UL; } while(0)
END_HASH(0x45535432UL); /* historical EST2 */
END_HASH(s.sequence);
END_HASH(s.tickHi);
END_HASH(s.tickLo);
END_HASH(s.worldCycle);
END_HASH(s.worldLocalTick);
END_HASH(s.nextModelId);
END_HASH(END_WORLD_BASE_SEED);
#undef END_HASH
return h;
}
FAST_CODE_2 static unsigned long stateChecksumV2(const EnduranceState & s)
{
unsigned long h = 2166136261UL;
#define END_HASH(v) do { h ^= (unsigned long)(v); h *= 16777619UL; } while(0)
END_HASH(0x45535433UL); /* "EST3": Step 6 adds architectureFailures */
END_HASH(s.sequence);
END_HASH(s.tickHi);
END_HASH(s.tickLo);
END_HASH(s.worldCycle);
END_HASH(s.worldLocalTick);
END_HASH(s.nextModelId);
END_HASH(s.architectureFailures);
END_HASH(END_WORLD_BASE_SEED);
#undef END_HASH
return h;
}
FAST_CODE_2 static unsigned long stateChecksumV3(const EnduranceState & s)
{
unsigned long h = 2166136261UL;
#define END_HASH(v) do { h ^= (unsigned long)(v); h *= 16777619UL; } while(0)
END_HASH(0x45535434UL); /* "EST4": Step 7 resource-aware architecture state */
END_HASH(s.sequence);
END_HASH(s.tickHi);
END_HASH(s.tickLo);
END_HASH(s.worldCycle);
END_HASH(s.worldLocalTick);
END_HASH(s.nextModelId);
END_HASH(s.architectureFailures);
END_HASH(s.architectureNextStage);
END_HASH(s.architectureParameterCeiling);
END_HASH(s.adaptationArchitectureStage);
END_HASH(s.architectureSaturated);
END_HASH(END_WORLD_BASE_SEED);
#undef END_HASH
return h;
}
FAST_CODE_2 static unsigned long stateChecksumV4(const EnduranceState & s)
{
unsigned long h = 2166136261UL;
#define END_HASH(v) do { h ^= (unsigned long)(v); h *= 16777619UL; } while(0)
END_HASH(0x45535435UL); /* "EST5": Step 8 compact architecture outcome memory */
END_HASH(s.sequence);
END_HASH(s.tickHi);
END_HASH(s.tickLo);
END_HASH(s.worldCycle);
END_HASH(s.worldLocalTick);
END_HASH(s.nextModelId);
END_HASH(s.architectureFailures);
END_HASH(s.architectureNextStage);
END_HASH(s.architectureParameterCeiling);
END_HASH(s.adaptationArchitectureStage);
END_HASH(s.architectureSaturated);
END_HASH(s.architectureAttemptedMask);
END_HASH(s.architectureOutcomeBits);
END_HASH(END_WORLD_BASE_SEED);
#undef END_HASH
return h;
}
FAST_CODE_2 static unsigned long stateChecksumV5(const EnduranceState & s)
{
unsigned long h = 2166136261UL;
#define END_HASH(v) do { h ^= (unsigned long)(v); h *= 16777619UL; } while(0)
END_HASH(0x45535436UL); /* "EST6": v0.25 Step 4 simplification lifecycle */
END_HASH(s.sequence);
END_HASH(s.tickHi);
END_HASH(s.tickLo);
END_HASH(s.worldCycle);
END_HASH(s.worldLocalTick);
END_HASH(s.nextModelId);
END_HASH(s.architectureFailures);
END_HASH(s.architectureNextStage);
END_HASH(s.architectureParameterCeiling);
END_HASH(s.adaptationArchitectureStage);
END_HASH(s.architectureSaturated);
END_HASH(s.architectureAttemptedMask);
END_HASH(s.architectureOutcomeBits);
END_HASH(s.simplificationStableSamples);
END_HASH(s.simplificationActiveAgeSamples);
END_HASH(s.simplificationPreviousAttemptKnown);
END_HASH(s.simplificationSamplesSinceAttempt);
END_HASH(s.simplificationLifecycleMode);
END_HASH(s.simplificationAttempts);
END_HASH(s.simplificationPromotions);
END_HASH(s.simplificationRejections);
END_HASH(s.simplificationRollbacks);
END_HASH(END_WORLD_BASE_SEED);
#undef END_HASH
return h;
}
FAST_CODE_2 static unsigned long stateChecksum(const EnduranceState & s)
{
unsigned long h = 2166136261UL;
#define END_HASH(v) do { h ^= (unsigned long)(v); h *= 16777619UL; } while(0)
END_HASH(0x45535437UL); /* "EST7": R2 SIMMEM1 simplification outcome memory */
END_HASH(s.sequence);
END_HASH(s.tickHi);
END_HASH(s.tickLo);
END_HASH(s.worldCycle);
END_HASH(s.worldLocalTick);
END_HASH(s.nextModelId);
END_HASH(s.architectureFailures);
END_HASH(s.architectureNextStage);
END_HASH(s.architectureParameterCeiling);
END_HASH(s.adaptationArchitectureStage);
END_HASH(s.architectureSaturated);
END_HASH(s.architectureAttemptedMask);
END_HASH(s.architectureOutcomeBits);
END_HASH(s.simplificationStableSamples);
END_HASH(s.simplificationActiveAgeSamples);
END_HASH(s.simplificationPreviousAttemptKnown);
END_HASH(s.simplificationSamplesSinceAttempt);
END_HASH(s.simplificationLifecycleMode);
END_HASH(s.simplificationAttempts);
END_HASH(s.simplificationPromotions);
END_HASH(s.simplificationRejections);
END_HASH(s.simplificationRollbacks);
END_HASH(s.simplificationBlockedParentModelId);
END_HASH(s.simplificationBlockedTargetInputs);
END_HASH(s.simplificationBlockedTargetOutputs);
END_HASH(s.simplificationBlockedTargetHiddenLayers);
END_HASH(s.simplificationBlockedTargetHidden0);
END_HASH(s.simplificationBlockedTargetHidden1);
END_HASH(s.simplificationBlockedTargetHidden2);
END_HASH(s.simplificationBlockedTargetHidden3);
END_HASH(s.simplificationBlockedOutcome);
END_HASH(END_WORLD_BASE_SEED);
#undef END_HASH
return h;
}
static unsigned long architectureStageBit(unsigned long stage)
{
if(stage > 9UL) return 0UL;
return 1UL << stage;
}
static unsigned long architectureBlockedMask(const EnduranceState & s)
{
unsigned long mask = 0UL;
unsigned long stage;
for(stage = 0UL; stage <= 9UL; ++stage)
{
if(((s.architectureOutcomeBits >> (stage * 2UL)) & 3UL) != 0UL)
mask |= architectureStageBit(stage);
}
return mask;
}
static void markArchitectureAttempt(unsigned long stage)
{
g_state.architectureAttemptedMask |= architectureStageBit(stage);
}
static void markArchitectureOutcome(unsigned long stage, unsigned long outcome)
{
unsigned long shift;
unsigned long mask;
if(stage > 9UL || outcome > 3UL) return;
markArchitectureAttempt(stage);
shift = stage * 2UL;
mask = 3UL << shift;
g_state.architectureOutcomeBits =
(g_state.architectureOutcomeBits & ~mask) | ((outcome & 3UL) << shift);
}
static unsigned long clampArchitectureStage(unsigned long stage)
{
return stage > 9UL ? 9UL : stage;
}
static const char * monitorName(int state)
{
switch(state)
{
case OTNN_MONITOR_LEARNING_REFERENCE: return "LEARNING";
case OTNN_MONITOR_GOOD: return "GOOD";
case OTNN_MONITOR_NOTICE: return "NOTICE";
case OTNN_MONITOR_WARNING: return "WARNING";
case OTNN_MONITOR_DEGRADED: return "DEGRADED";
case OTNN_MONITOR_RETRAIN_REQUIRED: return "RETRAIN";
}
return "UNKNOWN";
}
static const char * q15ModeName(int mode)
{
switch((otTinnMemoryMode)mode)
{
case OTNN_Q15_MEMORY_NORMAL: return "NORMAL";
case OTNN_Q15_MEMORY_FAST: return "FAST";
case OTNN_Q15_MEMORY_MIXED: return "MIXED";
default: return "NONE";
}
}
static void logTopologyInline(const otNNTopology & t)
{
int i;
if(g_logFile == 0) return;
file.fprintf(g_logFile, "%d", t.inputs);
for(i = 0; i < t.hiddenLayers; ++i) file.fprintf(g_logFile, "-%d", t.hidden[i]);
file.fprintf(g_logFile, "-%d", t.outputs);
}
static void printTopologyInline(const otNNTopology & t)
{
int i;
printf("%d", t.inputs);
for(i = 0; i < t.hiddenLayers; ++i) printf("-%d", t.hidden[i]);
printf("-%d", t.outputs);
}
/* Forward declarations: SIGNATURE2 logger is intentionally placed near the
* signature helpers, before the generic endurance logging implementation.
* Required by BF518 GCC 4.6.3 (the Win32 self-test branch does not compile
* this section, so missing declarations would otherwise escape host tests).
*/
static void logPrefix(const char * kind);
static void logEnd(int critical);
static void logModelPerformanceSignature(
const char * role,
const otNNModelPerformanceSignature & signature)
{
if(g_logFile == 0 || role == 0 || !signature.valid) return;
logPrefix("SIGNATURE");
file.fprintf(g_logFile, "role=%s modelId=%lu revision=%lu topology=",
role, signature.modelId, signature.revision);
logTopologyInline(signature.topology);
file.fprintf(g_logFile,
" quality[valid=%d class=%d samples=%lu acc=%.3f meanErr=%.7f maxErr=%.7f q15Prepared=%d q15Evaluated=%d q15Acc=%.3f q15MeanErr=%.7f q15MaxErr=%.7f]"
" complexity[valid=%d hidden=%d maxWidth=%d params=%lu MACs=%lu]"
" resources[floatParam=%lu floatRuntime=%lu trainWorkspace=%lu q15Ready=%d q15Bytes=%lu q15Fast=%lu q15Normal=%lu q15Mode=%s deploymentMemoryNormalized=%d floatLatencyValid=%d floatLatency=%.3f deploymentLatencyValid=%d deploymentLatency=%.3f]"
" lifecycle[available=%d activeAge=%lu stable=%lu] descriptiveOnly=1 aggregateScore=NONE",
signature.qualityValid,
signature.classificationAvailable,
signature.validationSamples,
(double)signature.accuracyPercent,
(double)signature.meanAbsError,
(double)signature.maxAbsError,
signature.q15Prepared,
signature.q15Evaluated,
(double)signature.q15AccuracyPercent,
(double)signature.q15MeanAbsError,
(double)signature.q15MaxAbsError,
signature.complexityValid,
signature.hiddenLayers,
signature.maxHiddenWidth,
signature.parameters,
signature.macsPerInference,
signature.floatParameterBytes,
signature.floatRuntimeBytes,
signature.trainingWorkspaceBytes,
signature.q15Ready,
signature.q15RuntimeBytes,
signature.q15FastBytes,
signature.q15NormalBytes,
q15ModeName(signature.q15MemoryMode),
signature.q15DeploymentMemoryOverrideUsed,
signature.floatLatencyValid,
(double)signature.floatLatencyUs,
signature.deploymentLatencyValid,
(double)signature.deploymentLatencyUs,
signature.lifecycleAvailable,
signature.activeAgeSamples,
signature.stableSamples);
logEnd(1);
}
static void tickAdvance()
{
++g_state.tickLo;
if(g_state.tickLo == 0UL) ++g_state.tickHi;
++g_state.worldLocalTick;
if(g_state.worldLocalTick >= END_WORLD_CYCLE_SAMPLES)
{
g_state.worldLocalTick = 0UL;
++g_state.worldCycle;
}
}
static int dateOlderThanReference(int y, int m, int d)
{
if(y < END_RTC_REFERENCE_YEAR) return 1;
if(y > END_RTC_REFERENCE_YEAR) return 0;
if(m < END_RTC_REFERENCE_MONTH) return 1;
if(m > END_RTC_REFERENCE_MONTH) return 0;
return d < END_RTC_REFERENCE_DAY;
}
static void rtcInitOnce()
{
U8 h = 0, m = 0, s = 0;
int yy = 0, mm = 0, dd = 0;
RtcOn();
RtcGetDate(&yy, &mm, &dd);
RtcGetTime(&h, &m, &s);
if(yy < 2020 || mm < 1 || mm > 12 || dd < 1 || dd > 31 ||
dateOlderThanReference(yy, mm, dd))
{
/* This test has been written in this date. */
RtcSetDate(END_RTC_REFERENCE_YEAR, END_RTC_REFERENCE_MONTH, END_RTC_REFERENCE_DAY);
RtcSetTime(END_RTC_REFERENCE_HOUR, END_RTC_REFERENCE_MINUTE, END_RTC_REFERENCE_SECOND);
g_rtcWasInitialized = 1;
}
}
static void logPrefix(const char * kind)
{
U8 h = 0, m = 0, s = 0;
int yy = 0, mm = 0, dd = 0;
if(g_logFile == 0) return;
RtcGetDate(&yy, &mm, &dd);
RtcGetTime(&h, &m, &s);
file.fprintf(g_logFile,
"[%04d/%02d/%02d %02d:%02d:%02d][%s][tick=%lu:%010lu] ",
yy, mm, dd, (int)h, (int)m, (int)s,
kind != 0 ? kind : "LOG", g_state.tickHi, g_state.tickLo);
}
static void logEnd(int critical)
{
if(g_logFile == 0) return;
file.fprintf(g_logFile, "\n");
if(critical) file.fsync(g_logFile);
}
static void logSimple(const char * kind, const char * text, int critical)
{
if(g_logFile == 0) return;
logPrefix(kind);
file.fprintf(g_logFile, "%s", text != 0 ? text : "");
logEnd(critical);
}
static void logDecisionTrace(const char * stage, int critical)
{
if(g_logFile == 0 || !g_decisionTrace.valid) return;
logPrefix("DECISION");
file.fprintf(g_logFile,
"stage=%s final=%d eligible=%d reason=%s quality[dAcc=%.4f dErr=%.7f errReduction=%.5f q15dAcc=%.4f q15dErr=%.7f q15ErrReduction=%.5f] cost[dParams=%ld paramInc=%.4f dMACs=%ld macInc=%.4f dFloatBytes=%ld floatInc=%.4f dWorkspace=%ld workspaceInc=%.4f dQ15Bytes=%ld q15Inc=%.4f q15LatencyAvail=%d dQ15Latency=%.4f q15LatencyInc=%.4f] gates[sample=%d float=%d q15=%d ready=%d latency=%d complexity=%d dominance=%d shadow=%d]",
stage != 0 ? stage : "unknown",
g_decisionTrace.finalDecisionKnown, g_decisionTrace.eligible,
otNeuralAutonomyController::promotionDecisionReasonName(g_decisionTrace.reason),
(double)g_decisionTrace.floatAccuracyDeltaPoints,
(double)g_decisionTrace.floatMeanErrorDelta,
(double)g_decisionTrace.floatMeanErrorReductionRatio,
(double)g_decisionTrace.q15AccuracyDeltaPoints,
(double)g_decisionTrace.q15MeanErrorDelta,
(double)g_decisionTrace.q15MeanErrorReductionRatio,
g_decisionTrace.parameterDelta, (double)g_decisionTrace.parameterIncreaseRatio,
g_decisionTrace.macDelta, (double)g_decisionTrace.macIncreaseRatio,
g_decisionTrace.floatRuntimeBytesDelta, (double)g_decisionTrace.floatRuntimeIncreaseRatio,
g_decisionTrace.trainingWorkspaceBytesDelta, (double)g_decisionTrace.trainingWorkspaceIncreaseRatio,
g_decisionTrace.q15RuntimeBytesDelta, (double)g_decisionTrace.q15RuntimeIncreaseRatio,
g_decisionTrace.q15LatencyDeltaAvailable, (double)g_decisionTrace.q15LatencyDeltaUs,
(double)g_decisionTrace.q15LatencyIncreaseRatio,
g_gateReport.sampleGate, g_gateReport.floatQualityGate,
g_gateReport.q15QualityGate, g_gateReport.q15ReadyGate,
g_gateReport.q15LatencyGate, g_gateReport.complexity.eligible,
g_gateReport.dominanceGate, g_gateReport.shadowGate);
logEnd(critical);
}
static bool updateDecisionTrace(const otNNShadowReport * shadow,
const char * stage, int critical)
{
memset(&g_decisionTrace, 0, sizeof(g_decisionTrace));
if(!otNeuralAutonomyController::buildPromotionDecisionTrace(
g_activeSignature, g_candidateSignature,
g_improvementReport, g_dominanceReport, g_gateReport, shadow,
g_decisionTrace))
return false;
logDecisionTrace(stage, critical);
return true;
}
static bool openEnduranceLog()
{
g_logFile = file.fopen(END_LOG_FILE, otFILE::A_OPEN_APPEND | otFILE::A_WRITE);
return g_logFile != 0;
}
static void closeEnduranceLog()
{
if(g_logFile != 0)
{
file.fsync(g_logFile);
file.fclose(g_logFile);
g_logFile = 0;
}
}
/* Non-blocking UART console.
* ESC : clean stop/checkpoint/commit/close
* ? : minimal read-only live status; endurance continues uninterrupted.
* Cold diagnostic code is kept out of scarce L1 CODE. */
FAST_CODE_2 static void printLiveStatus()
{
otNNModelDescriptor a, c, p;
otNNComplexityReport activeComplexity;
unsigned long activeParameters = 0UL;
const int hasA = g_lifecycle.activeDescriptor(a) ? 1 : 0;
const int hasC = g_lifecycle.candidateDescriptor(c) ? 1 : 0;
const int hasP = g_lifecycle.previousDescriptor(p) ? 1 : 0;
const int phase = g_controller.phase();
const int monitor = (int)g_monitor.state();
memset(&activeComplexity, 0, sizeof(activeComplexity));
if(hasA && otNeuralModelLifecycle::buildComplexityReport(
g_lifecycle.activeModel(), a, 0, activeComplexity))
activeParameters = activeComplexity.parameters;
printf("\n[STATUS] tick=%lu:%lu world=%lu/%lu monitor=%s phase=%s heap=%lu\n",
g_state.tickHi, g_state.tickLo, g_state.worldCycle, g_state.worldLocalTick,
monitorName(monitor), otNeuralAutonomyController::phaseName(phase),
(unsigned long)_memFree());
if(hasA)
{
printf("[STATUS] generation(modelId)=%lu revision=%lu topology=",
a.modelId, a.revision);
printTopologyInline(a.topology);
printf(" params=%lu nextModelId=%lu\n",
activeParameters, g_state.nextModelId);
}
else
printf("[STATUS] ACTIVE=none nextModelId=%lu\n", g_state.nextModelId);
printf("[STATUS] roles candidate=%s previous=%s arch[fail=%lu next=%lu cap=%lu%s]\n",
hasC ? "yes" : "no", hasP ? "yes" : "no",
g_state.architectureFailures, g_state.architectureNextStage,
g_state.architectureParameterCeiling,
g_state.architectureSaturated ? " SATURATED" : "");
printf("[STATUS] simplify[mode=%lu stable=%lu activeAge=%lu sinceAttempt=%lu attempts=%lu promote=%lu reject=%lu rollback=%lu]\n",
g_state.simplificationLifecycleMode,
g_state.simplificationStableSamples,
g_state.simplificationActiveAgeSamples,
g_state.simplificationPreviousAttemptKnown ?
g_state.simplificationSamplesSinceAttempt : 0UL,
g_state.simplificationAttempts,
g_state.simplificationPromotions,
g_state.simplificationRejections,
g_state.simplificationRollbacks);
{
otNNTrainingProgress tp;
memset(&tp, 0, sizeof(tp));
g_trainingSession.progress(tp);
printf("[STATUS] training[state=%d epoch=%lu/%lu sample=%lu trained=%lu checkpointSeq=%lu]\n",
tp.state, tp.currentEpoch, tp.totalEpochs, tp.sampleIndex,
tp.samplesTrained, tp.checkpointSequence);
}
if(g_state.simplificationBlockedOutcome != SIMPLIFY_BLOCK_NONE)
{
printf("[STATUS] simplifyMemory[parent=%lu target=%lu-",
g_state.simplificationBlockedParentModelId,
g_state.simplificationBlockedTargetInputs);
if(g_state.simplificationBlockedTargetHiddenLayers > 0UL)
printf("%lu", g_state.simplificationBlockedTargetHidden0);
if(g_state.simplificationBlockedTargetHiddenLayers > 1UL)
printf("-%lu", g_state.simplificationBlockedTargetHidden1);
if(g_state.simplificationBlockedTargetHiddenLayers > 2UL)
printf("-%lu", g_state.simplificationBlockedTargetHidden2);
if(g_state.simplificationBlockedTargetHiddenLayers > 3UL)
printf("-%lu", g_state.simplificationBlockedTargetHidden3);
printf("-%lu outcome=%s]\n\n",
g_state.simplificationBlockedTargetOutputs,
g_state.simplificationBlockedOutcome == SIMPLIFY_BLOCK_ROLLBACK ?
"ROLLBACK" : "REJECT");
}
else
printf("[STATUS] simplifyMemory[none]\n\n");
}
FAST_CODE_2 static bool stopRequested()
{
if(UartCheckChar(UART0))
{
const U8 ch = UartGetChar(UART0);
if(ch == 27U) return true;
if(ch == (U8)'?') printLiveStatus();
}
return false;
}
/* ------------------------------------------------------------------------- */
/* Small power-loss-tolerant A/B endurance cursor. */
/* ------------------------------------------------------------------------- */
FAST_CODE_2 static bool parseUnsignedToken(const char * & p, unsigned long & value)
{
unsigned long v = 0UL;
unsigned long digit;
if(p == 0) return false;
while(*p == ' ' || *p == '\t' || *p == '\r' || *p == '\n') ++p;
if(*p < '0' || *p > '9') return false;
while(*p >= '0' && *p <= '9')
{
digit = (unsigned long)(*p - '0');
/* Endurance fields are serialized as 32-bit unsigned decimal values.
Keep parsing identical on Win32 and BF518 and reject overflow. */
if(v > 429496729UL || (v == 429496729UL && digit > 5UL)) return false;
v = v * 10UL + digit;
++p;
}
value = v;
return true;
}
FAST_CODE_2 static bool onlyWhitespaceRemains(const char * p)
{
if(p == 0) return false;
while(*p != 0)
{
if(*p != ' ' && *p != '\t' && *p != '\r' && *p != '\n') return false;
++p;
}
return true;
}
/* BOOTFIX3 / otFILE v2.0.2: endurance files are intentionally written as
ONE text line. Read that physical record exactly once with the safe
caller-buffer freadline() API, reject truncation explicitly, then tokenize
unsigned decimal fields locally. No heap allocation is required here. */
FAST_CODE_2 static bool readStateFile(const char * path, EnduranceState & out,
unsigned long * versionOut)
{
FILE f;
char * line;
const char * cur;
unsigned long magic = 0UL;
unsigned long version = 0UL;
bool lineTruncated = false;
bool ok = true;
memset(&out, 0, sizeof(out));
if(versionOut != 0) *versionOut = 0UL;
f = file.fopen(path, otFILE::A_READ);
if(f == 0) return false;
line = file.freadline(g_enduranceStateLine, END_STATE_LINE_BUFFER_SIZE,
f, '\n', true, &lineTruncated);
file.fclose(f);
if(line == 0 || lineTruncated) return false;
cur = line;
#define READ_STATE_UL(v) do { if(ok && !parseUnsignedToken(cur, (v))) ok = false; } while(0)
READ_STATE_UL(magic);
READ_STATE_UL(version);
if(versionOut != 0 && ok) *versionOut = version;
if(!ok || magic != 0x45535432UL)
{
return false;
}
if(version == 1UL)
{
READ_STATE_UL(out.sequence);
READ_STATE_UL(out.tickHi);
READ_STATE_UL(out.tickLo);
READ_STATE_UL(out.worldCycle);
READ_STATE_UL(out.worldLocalTick);
READ_STATE_UL(out.nextModelId);
READ_STATE_UL(out.checksum);
if(ok && !onlyWhitespaceRemains(cur)) ok = false;
if(ok && out.checksum != stateChecksumV1(out)) ok = false;
}
else if(version == 2UL)
{
READ_STATE_UL(out.sequence);
READ_STATE_UL(out.tickHi);
READ_STATE_UL(out.tickLo);
READ_STATE_UL(out.worldCycle);
READ_STATE_UL(out.worldLocalTick);
READ_STATE_UL(out.nextModelId);
READ_STATE_UL(out.architectureFailures);
READ_STATE_UL(out.checksum);
if(ok && !onlyWhitespaceRemains(cur)) ok = false;
if(ok && out.checksum != stateChecksumV2(out)) ok = false;
out.architectureNextStage = clampArchitectureStage(out.architectureFailures);
out.adaptationArchitectureStage = out.architectureNextStage;
}
else if(version == 3UL)
{
READ_STATE_UL(out.sequence);
READ_STATE_UL(out.tickHi);
READ_STATE_UL(out.tickLo);
READ_STATE_UL(out.worldCycle);
READ_STATE_UL(out.worldLocalTick);
READ_STATE_UL(out.nextModelId);
READ_STATE_UL(out.architectureFailures);
READ_STATE_UL(out.architectureNextStage);
READ_STATE_UL(out.architectureParameterCeiling);
READ_STATE_UL(out.adaptationArchitectureStage);
READ_STATE_UL(out.architectureSaturated);
READ_STATE_UL(out.checksum);
if(ok && !onlyWhitespaceRemains(cur)) ok = false;
if(ok && out.checksum != stateChecksumV3(out)) ok = false;
}
else if(version == 4UL)
{
READ_STATE_UL(out.sequence);
READ_STATE_UL(out.tickHi);
READ_STATE_UL(out.tickLo);
READ_STATE_UL(out.worldCycle);
READ_STATE_UL(out.worldLocalTick);
READ_STATE_UL(out.nextModelId);
READ_STATE_UL(out.architectureFailures);
READ_STATE_UL(out.architectureNextStage);
READ_STATE_UL(out.architectureParameterCeiling);
READ_STATE_UL(out.adaptationArchitectureStage);
READ_STATE_UL(out.architectureSaturated);
READ_STATE_UL(out.architectureAttemptedMask);
READ_STATE_UL(out.architectureOutcomeBits);
READ_STATE_UL(out.checksum);
if(ok && !onlyWhitespaceRemains(cur)) ok = false;
if(ok && out.checksum != stateChecksumV4(out)) ok = false;
}
else if(version == 5UL)
{
READ_STATE_UL(out.sequence);
READ_STATE_UL(out.tickHi);
READ_STATE_UL(out.tickLo);
READ_STATE_UL(out.worldCycle);
READ_STATE_UL(out.worldLocalTick);
READ_STATE_UL(out.nextModelId);
READ_STATE_UL(out.architectureFailures);
READ_STATE_UL(out.architectureNextStage);
READ_STATE_UL(out.architectureParameterCeiling);
READ_STATE_UL(out.adaptationArchitectureStage);
READ_STATE_UL(out.architectureSaturated);
READ_STATE_UL(out.architectureAttemptedMask);
READ_STATE_UL(out.architectureOutcomeBits);
READ_STATE_UL(out.simplificationStableSamples);
READ_STATE_UL(out.simplificationActiveAgeSamples);
READ_STATE_UL(out.simplificationPreviousAttemptKnown);
READ_STATE_UL(out.simplificationSamplesSinceAttempt);
READ_STATE_UL(out.simplificationLifecycleMode);
READ_STATE_UL(out.simplificationAttempts);
READ_STATE_UL(out.simplificationPromotions);
READ_STATE_UL(out.simplificationRejections);
READ_STATE_UL(out.simplificationRollbacks);
READ_STATE_UL(out.checksum);
if(ok && !onlyWhitespaceRemains(cur)) ok = false;
if(ok && out.checksum != stateChecksumV5(out)) ok = false;
/* v5 has no SIMMEM1 fields; memset() intentionally left them zero. */
}
else if(version == 6UL)
{
READ_STATE_UL(out.sequence);
READ_STATE_UL(out.tickHi);
READ_STATE_UL(out.tickLo);
READ_STATE_UL(out.worldCycle);
READ_STATE_UL(out.worldLocalTick);
READ_STATE_UL(out.nextModelId);
READ_STATE_UL(out.architectureFailures);
READ_STATE_UL(out.architectureNextStage);
READ_STATE_UL(out.architectureParameterCeiling);
READ_STATE_UL(out.adaptationArchitectureStage);
READ_STATE_UL(out.architectureSaturated);
READ_STATE_UL(out.architectureAttemptedMask);
READ_STATE_UL(out.architectureOutcomeBits);
READ_STATE_UL(out.simplificationStableSamples);
READ_STATE_UL(out.simplificationActiveAgeSamples);
READ_STATE_UL(out.simplificationPreviousAttemptKnown);
READ_STATE_UL(out.simplificationSamplesSinceAttempt);
READ_STATE_UL(out.simplificationLifecycleMode);
READ_STATE_UL(out.simplificationAttempts);
READ_STATE_UL(out.simplificationPromotions);
READ_STATE_UL(out.simplificationRejections);
READ_STATE_UL(out.simplificationRollbacks);
READ_STATE_UL(out.simplificationBlockedParentModelId);
READ_STATE_UL(out.simplificationBlockedTargetInputs);
READ_STATE_UL(out.simplificationBlockedTargetOutputs);
READ_STATE_UL(out.simplificationBlockedTargetHiddenLayers);
READ_STATE_UL(out.simplificationBlockedTargetHidden0);
READ_STATE_UL(out.simplificationBlockedTargetHidden1);
READ_STATE_UL(out.simplificationBlockedTargetHidden2);
READ_STATE_UL(out.simplificationBlockedTargetHidden3);
READ_STATE_UL(out.simplificationBlockedOutcome);
READ_STATE_UL(out.checksum);
if(ok && !onlyWhitespaceRemains(cur)) ok = false;
if(ok && out.checksum != stateChecksum(out)) ok = false;
}
else
ok = false;
#undef READ_STATE_UL
if(!ok) return false;
if(out.worldLocalTick >= END_WORLD_CYCLE_SAMPLES) return false;
if(out.nextModelId == 0UL) return false;
if(out.architectureNextStage > 9UL || out.adaptationArchitectureStage > 9UL) return false;
if(out.architectureSaturated > 1UL) return false;
if((out.architectureAttemptedMask & ~0x3FFUL) != 0UL) return false;
if((out.architectureOutcomeBits & ~0xFFFFFUL) != 0UL) return false;
if(out.simplificationPreviousAttemptKnown > 1UL) return false;
if(out.simplificationLifecycleMode > 2UL) return false;
if(out.simplificationBlockedOutcome > 2UL) return false;
if(out.simplificationBlockedOutcome != 0UL)
{
if(out.simplificationBlockedParentModelId == 0UL) return false;
if(out.simplificationBlockedTargetInputs == 0UL ||
out.simplificationBlockedTargetOutputs == 0UL ||
out.simplificationBlockedTargetHiddenLayers == 0UL ||
out.simplificationBlockedTargetHiddenLayers > OTNN_MAX_HIDDEN_LAYERS)
return false;
}
out.valid = 1UL;
return true;
}
FAST_CODE_2 static bool writeStateFile(const char * path, EnduranceState & value)
{
FILE f;
value.checksum = stateChecksum(value);
f = file.fopen(path, otFILE::A_CREATE_ALWAYS | otFILE::A_WRITE);
if(f == 0) return false;
if(file.fprintf(f, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu\n",
0x45535432UL, 6UL, value.sequence,
value.tickHi, value.tickLo,
value.worldCycle, value.worldLocalTick,
value.nextModelId, value.architectureFailures,
value.architectureNextStage, value.architectureParameterCeiling,
value.adaptationArchitectureStage, value.architectureSaturated,
value.architectureAttemptedMask, value.architectureOutcomeBits,
value.simplificationStableSamples,
value.simplificationActiveAgeSamples,
value.simplificationPreviousAttemptKnown,
value.simplificationSamplesSinceAttempt,
value.simplificationLifecycleMode,
value.simplificationAttempts,
value.simplificationPromotions,
value.simplificationRejections,
value.simplificationRollbacks,
value.simplificationBlockedParentModelId,
value.simplificationBlockedTargetInputs,
value.simplificationBlockedTargetOutputs,
value.simplificationBlockedTargetHiddenLayers,
value.simplificationBlockedTargetHidden0,
value.simplificationBlockedTargetHidden1,
value.simplificationBlockedTargetHidden2,
value.simplificationBlockedTargetHidden3,
value.simplificationBlockedOutcome,
value.checksum) < 0)
{
file.fclose(f);
return false;
}
if(!file.fsync(f))
{
file.fclose(f);
return false;
}
return file.fclose(f);
}
FAST_CODE_2 static bool loadEnduranceState()
{
EnduranceState a;
EnduranceState b;
bool va;
bool vb;
g_stateAExists = file.fsize(END_STATE_A) > 0UL ? 1UL : 0UL;
g_stateBExists = file.fsize(END_STATE_B) > 0UL ? 1UL : 0UL;
g_stateAVersion = 0UL;
g_stateBVersion = 0UL;
va = readStateFile(END_STATE_A, a, &g_stateAVersion);
vb = readStateFile(END_STATE_B, b, &g_stateBVersion);
g_stateAValid = va ? 1UL : 0UL;
g_stateBValid = vb ? 1UL : 0UL;
g_stateASequence = va ? a.sequence : 0UL;
g_stateBSequence = vb ? b.sequence : 0UL;
g_stateSelectedSlot = 0UL;
g_enduranceStateRestored = 0UL;
memset(&g_state, 0, sizeof(g_state));
g_state.valid = 1UL;
g_state.nextModelId = 1000UL;
if(va && (!vb || a.sequence >= b.sequence))
{
g_state = a;
g_stateSelectedSlot = 1UL;
g_enduranceStateRestored = 1UL;
}
else if(vb)
{
g_state = b;
g_stateSelectedSlot = 2UL;
g_enduranceStateRestored = 1UL;
}
return g_enduranceStateRestored != 0UL;
}
FAST_CODE_2 static bool saveEnduranceState()
{
const char * path;
EnduranceState next = g_state;
++next.sequence;
path = (next.sequence & 1UL) ? END_STATE_A : END_STATE_B;
if(!writeStateFile(path, next)) return false;
g_state = next;
g_lastStateSaveTickLo = g_state.tickLo;
return true;
}
/* ------------------------------------------------------------------------- */
/* World generator */
/* ------------------------------------------------------------------------- */
static bool configureWorldCycle(unsigned long cycle)
{
unsigned long r = mix32(END_WORLD_BASE_SEED ^ (cycle * 0x9E3779B9UL));
int i;
const int calmTail = END_CALM_TAIL_ENABLED &&
cycle >= END_CALM_TAIL_START_CYCLE;
g_worldSeed = r ? r : 1UL;
g_world.reset((unsigned int)g_worldSeed);
g_world.clearEvents();
g_world.setInputClamp(true, 0.0f, 1.0f);
if(calmTail)
{
/* CALM TAIL: deliberately remove every synthetic perturbation.
* No events are installed, therefore applyAt() returns the original
* input/target (subject only to the normal [0,1] input clamp).
*
* Do NOT reset the monitor here: the purpose of the experiment is to
* verify that the existing lifecycle naturally accumulates the normal
* 24k stability dwell and reaches autonomous simplification. */
g_worldGain = 1.0f;
g_worldOffset = 0.0f;
g_worldNoise = 0.0f;
for(i = 0; i < 10; ++i) g_worldPairs[i] = i;
logPrefix("WORLD");
file.fprintf(g_logFile,
"cycle=%lu mode=CALM_TAIL seed=0x%08lX gain=1.0000 offset=0.0000 noise=0.0000 targetDrift=OFF startCycle=%lu",
cycle, g_worldSeed, END_CALM_TAIL_START_CYCLE);
logEnd(1);
printf("[WORLD] cycle=%lu mode=CALM_TAIL gain=1.000 offset=0.000 noise=0.000 targetDrift=OFF\n",
cycle);
return true;
}
/* Original R2 deterministic aggressive world. */
g_worldGain = 0.78f + (float)(nextRandom(r) % 31UL) / 100.0f; /* 0.78..1.08 */
g_worldOffset = ((float)((long)(nextRandom(r) % 161UL) - 80L)) / 1000.0f; /* -0.080..+0.080 */
g_worldNoise = 0.025f + (float)(nextRandom(r) % 96UL) / 1000.0f; /* 0.025..0.120 */
for(i = 0; i < 10; ++i) g_worldPairs[i] = i;
for(i = 9; i > 0; --i)
{
const int j = (int)(nextRandom(r) % (unsigned long)(i + 1));
const int t = g_worldPairs[i];
g_worldPairs[i] = g_worldPairs[j];
g_worldPairs[j] = t;
}
if(!g_world.addInputGain(OTNN_SCENARIO_ALL_CHANNELS, 1500, 4500, 1.0f, g_worldGain)) return false;
if(!g_world.addInputOffset(OTNN_SCENARIO_ALL_CHANNELS, 2500, 5500, 0.0f, g_worldOffset)) return false;
if(!g_world.addInputNoise(OTNN_SCENARIO_ALL_CHANNELS, 3500, 7000, 0.0f, g_worldNoise)) return false;
for(i = 0; i < 10; i += 2)
{
if(!g_world.addTargetClassSwap(g_worldPairs[i], g_worldPairs[i + 1],
6000, 10000, 0.0f, 1.0f))
return false;
}
logPrefix("WORLD");
file.fprintf(g_logFile,
"cycle=%lu mode=AGGRESSIVE seed=0x%08lX gain=%.4f offset=%.4f noise=%.4f pairs=%d-%d,%d-%d,%d-%d,%d-%d,%d-%d",
cycle, g_worldSeed, (double)g_worldGain,
(double)g_worldOffset, (double)g_worldNoise,
g_worldPairs[0], g_worldPairs[1], g_worldPairs[2], g_worldPairs[3],
g_worldPairs[4], g_worldPairs[5], g_worldPairs[6], g_worldPairs[7],
g_worldPairs[8], g_worldPairs[9]);
logEnd(1);
printf("[WORLD] cycle=%lu mode=AGGRESSIVE seed=0x%08lX gain=%.3f offset=%.3f noise=%.3f\n",
cycle, g_worldSeed, (double)g_worldGain,
(double)g_worldOffset, (double)g_worldNoise);
return true;
}
static bool writeFloatVector(FILE f, const float * v, int count)
{
int i = 0;
while(i + 8 <= count)
{
if(file.fprintf(f,
"%.7f %.7f %.7f %.7f %.7f %.7f %.7f %.7f ",
(double)v[i], (double)v[i+1], (double)v[i+2], (double)v[i+3],
(double)v[i+4], (double)v[i+5], (double)v[i+6], (double)v[i+7]) < 0)
return false;
i += 8;
}
while(i < count)
{
if(file.fprintf(f, "%.7f ", (double)v[i]) < 0) return false;
++i;
}
return true;
}
static bool buildWorldDataset(const char * path, unsigned long salt)
{
FILE f;
int row;
const int rows = g_sourceFramework.rows();
if(rows <= 0) return false;
f = file.fopen(path, otFILE::A_CREATE_ALWAYS | otFILE::A_WRITE);
if(f == 0) return false;
for(row = 0; row < rows; ++row)
{
unsigned long probe = g_state.worldLocalTick +
((unsigned long)row * 37UL + salt) % 751UL;
if(probe >= END_WORLD_CYCLE_SAMPLES) probe = END_WORLD_CYCLE_SAMPLES - 1UL;
if(!g_world.applyAt((otNeuralScenarioTick)probe,
g_sourceFramework.input(row), g_sourceFramework.target(row),
g_worldInput, g_worldTarget) ||
!writeFloatVector(f, g_worldInput, END_INPUTS) ||
!writeFloatVector(f, g_worldTarget, END_OUTPUTS) ||
file.fprintf(f, "\n") < 0)
{
file.fclose(f);
return false;
}
}
if(!file.fsync(f))
{
file.fclose(f);
return false;
}
return file.fclose(f);
}
/* ------------------------------------------------------------------------- */
/* Lifecycle bootstrap / restore */
/* ------------------------------------------------------------------------- */
static otTinn * findFreeModelStorage()
{
otTinn * a = g_lifecycle.activeModel();
otTinn * c = g_lifecycle.candidateModel();
otTinn * p = g_lifecycle.previousModel();
otTinn * all[3] = { &g_model0, &g_model1, &g_model2 };
int i;
for(i = 0; i < 3; ++i)
if(all[i] != a && all[i] != c && all[i] != p) return all[i];
return 0;
}
static unsigned long largestRoleModelId()
{
otNNModelDescriptor d;
unsigned long m = 0UL;
if(g_lifecycle.activeDescriptor(d) && d.modelId > m) m = d.modelId;
if(g_lifecycle.candidateDescriptor(d) && d.modelId > m) m = d.modelId;
if(g_lifecycle.previousDescriptor(d) && d.modelId > m) m = d.modelId;
return m;
}
static bool bootstrapOrRestoreLifecycle()
{
bool restored;
bool manifestsExist;
otNNModelDescriptor d;
int nips = 0, nops = 0, nhid = 0;
g_storage.init(&file);
g_lifecycle.reset();
g_model0.close();
g_model1.close();
g_model2.close();
restored = g_storage.loadLatestSnapshot(END_LIFECYCLE_PREFIX, g_lifecycle,
&g_model0, &g_model1, &g_model2,
g_catalogReport);
if(restored)
{
g_lifecycleRestoredFromCatalog = 1UL;
if(g_lifecycle.activeModel() == 0 || !g_lifecycle.activeModel()->prepareQ15())
return false;
logPrefix("BOOT");
file.fprintf(g_logFile, "catalog=RESTORED seq=%lu slot=%c active=%lu/r%lu candidate=%s previous=%s q15=READY",
g_catalogReport.sequence, g_catalogReport.slot,
g_catalogReport.active.modelId, g_catalogReport.active.revision,
g_catalogReport.candidateOccupied ? "yes" : "no",
g_catalogReport.previousOccupied ? "yes" : "no");
logEnd(1);
return true;
}
manifestsExist = file.fsize("v022_endurance_lifecycle_A.otl") > 0UL ||
file.fsize("v022_endurance_lifecycle_B.otl") > 0UL;
if(manifestsExist)
{
logSimple("ERROR", "lifecycle manifests exist but neither A nor B is valid", 1);
return false;
}
/* BOOTFIX1: never manufacture a fresh lifecycle beside a restored
endurance cursor. That would turn a detectable partial restore into a
new on-card catalog and make recovery less auditable. Fail closed before
touching lifecycle storage. */
if(g_enduranceStateRestored)
{
logSimple("ERROR", "endurance state restored but lifecycle catalog is absent; refusing bootstrap", 1);
return false;
}
g_lifecycleRestoredFromCatalog = 0UL;
if(!g_model0.init(END_INPUTS, END_OUTPUTS, END_BOOTSTRAP_HIDDEN, &file)) return false;
if(!g_model0.load(END_BOOTSTRAP_MODEL)) return false;
g_model0.properties(nips, nops, nhid);
otNeuralTrainingSession::makeDescriptor(d, 100UL, 1UL, nips, nops, nhid);
if(!g_lifecycle.attachActive(&g_model0, d)) return false;
if(!g_model0.prepareQ15()) return false;
if(!g_storage.saveSnapshot(END_LIFECYCLE_PREFIX, g_lifecycle, g_catalogReport)) return false;
if(g_state.nextModelId <= d.modelId) g_state.nextModelId = d.modelId + 1UL;
logPrefix("BOOT");
file.fprintf(g_logFile, "catalog=BOOTSTRAP active=%lu/r%lu source=%s seq=%lu slot=%c",
d.modelId, d.revision, END_BOOTSTRAP_MODEL,
g_catalogReport.sequence, g_catalogReport.slot);
logEnd(1);
return true;
}
static bool commitLifecycle(const char * reason)
{
if(!g_storage.saveSnapshot(END_LIFECYCLE_PREFIX, g_lifecycle, g_catalogReport))
return false;
logPrefix("COMMIT");
file.fprintf(g_logFile, "reason=%s seq=%lu slot=%c active=%lu/r%lu candidate=%s previous=%s",
reason != 0 ? reason : "unspecified",
g_catalogReport.sequence, g_catalogReport.slot,
g_catalogReport.active.modelId, g_catalogReport.active.revision,
g_catalogReport.candidateOccupied ? "yes" : "no",
g_catalogReport.previousOccupied ? "yes" : "no");
logEnd(1);
return true;
}
/* ------------------------------------------------------------------------- */
/* Runtime scheduling / telemetry */
/* ------------------------------------------------------------------------- */
static int scheduledWindow()
{
const unsigned long slot = g_state.tickLo & 1023UL;
if(g_retryCooldown > 0UL) return OTNN_WINDOW_REALTIME;
if(slot < 768UL) return OTNN_WINDOW_REALTIME;
if(slot < 896UL) return OTNN_WINDOW_IDLE;
if(slot < 992UL) return OTNN_WINDOW_CHARGING;
return OTNN_WINDOW_MAINTENANCE;
}
static void printSerialEvent(const char * name)
{
U8 h = 0, m = 0, s = 0;
int yy = 0, mm = 0, dd = 0;
RtcGetDate(&yy, &mm, &dd);
RtcGetTime(&h, &m, &s);
printf("[%04d/%02d/%02d %02d:%02d:%02d] %s\n",
yy, mm, dd, (int)h, (int)m, (int)s, name);
}
static void logTelemetry(float sampleError)
{
otNeuralMonitorInfo mi;
otNNAutonomyStatus as;
otTinnQ15MemoryInfo qi;
otNNModelDescriptor a, c, p;
unsigned long activeId = 0, activeRev = 0, candidateId = 0, previousId = 0;
const int hasA = g_lifecycle.activeDescriptor(a) ? 1 : 0;
const int hasC = g_lifecycle.candidateDescriptor(c) ? 1 : 0;
const int hasP = g_lifecycle.previousDescriptor(p) ? 1 : 0;
g_monitor.info(mi);
g_controller.status(as);
memset(&qi, 0, sizeof(qi));
if(g_lifecycle.activeModel() != 0) g_lifecycle.activeModel()->q15MemoryInfo(qi);
if(hasA) { activeId = a.modelId; activeRev = a.revision; }
if(hasC) candidateId = c.modelId;
if(hasP) previousId = p.modelId;
logPrefix("TELEMETRY");
file.fprintf(g_logFile,
"cycle=%lu local=%lu window=%s monitor=%s err=%.7f ratio=%.3f phase=%s active=%lu/r%lu candidate=%lu previous=%lu q15=%s heap=%lu fast1=%lu fast2=%lu logBytes=%lu promotions=%lu rollbacks=%lu rejections=%lu checkpoints=%lu archFailures=%lu simplify[mode=%lu stable=%lu activeAge=%lu sinceAttempt=%lu attempts=%lu promotions=%lu rejections=%lu rollbacks=%lu]",
g_state.worldCycle, g_state.worldLocalTick,
otNeuralAutonomyController::windowName(as.window), monitorName(mi.state),
(double)sampleError, (double)mi.errorRatio,
otNeuralAutonomyController::phaseName(as.phase),
activeId, activeRev, candidateId, previousId,
q15ModeName(qi.mode), (unsigned long)_memFree(),
qi.fast1Free, qi.fast2Free, file.fsize(END_LOG_FILE),
g_promotionsTotal, g_rollbacksTotal, g_rejectionsTotal, g_checkpointsTotal,
g_state.architectureFailures,
g_state.simplificationLifecycleMode,
g_state.simplificationStableSamples,
g_state.simplificationActiveAgeSamples,
g_state.simplificationSamplesSinceAttempt,
g_state.simplificationAttempts,
g_state.simplificationPromotions,
g_state.simplificationRejections,
g_state.simplificationRollbacks);
logEnd(0);
}
static float measureModelQ15Latency(otTinn * model)
{
const float * in;
unsigned long i;
unsigned long elapsed;
volatile short sink = 0;
if(model == 0 || !g_validationFramework.valid()) return -1.0f;
in = g_validationFramework.input(0);
if(in == 0 || !model->quantizeInputQ15(in, g_qInput)) return -1.0f;
ElapsedTimeStart(END_BENCH_TIMER);
for(i = 0; i < END_LATENCY_ITERATIONS; ++i)
{
const short * out = model->predictQ15Raw(g_qInput);
if(out == 0) return -1.0f;
sink = out[0];
}
elapsed = (unsigned long)ElapsedTimeEndUs(END_BENCH_TIMER);
(void)sink;
return (float)elapsed / (float)END_LATENCY_ITERATIONS;
}
/* ========================================================================
* TOPPA HARDWARE BF518 - IMPORTANT
*
* ACTIVE must retain first claim on fast Q15 memory during real shadow. That is
* the safe runtime rule and it is NOT changed here. Unfortunately it makes the
* resident CANDIDATE latency unsuitable as a deployment-cost comparison: the
* Candidate is timed while carrying a memory-placement handicap that disappears
* after promotion.
*
* This helper temporarily benchmarks CANDIDATE with the same fast-memory claim
* it would receive as ACTIVE, then restores the production shadow placement:
* ACTIVE first, CANDIDATE second. The Candidate never gains actuation authority.
*
* This is deliberately documented as a HARDWARE WORKAROUND / TOPPA. It should
* disappear if a future target can host both runtimes with equivalent memory
* residency, or if a dedicated deployment-cost estimator replaces it.
* ======================================================================== */
FAST_CODE_2 static bool measureBF518DeploymentLatencyPatch(
float & activeLatencyUs,
float & candidateShadowLatencyUs,
float & candidateDeploymentLatencyUs)
{
otTinn * active = g_lifecycle.activeModel();
otTinn * candidate = g_lifecycle.candidateModel();
int deploymentPrepared = 0;
int activeRestored = 0;
int candidateRestored = 0;
activeLatencyUs = -1.0f;
candidateShadowLatencyUs = -1.0f;
candidateDeploymentLatencyUs = -1.0f;
memset(&g_r2ActiveShadowQ15, 0, sizeof(g_r2ActiveShadowQ15));
memset(&g_r2CandidateShadowQ15, 0, sizeof(g_r2CandidateShadowQ15));
memset(&g_r2CandidateDeploymentQ15, 0, sizeof(g_r2CandidateDeploymentQ15));
memset(&g_r2ActiveRestoredQ15, 0, sizeof(g_r2ActiveRestoredQ15));
memset(&g_r2CandidateRestoredQ15, 0, sizeof(g_r2CandidateRestoredQ15));
if(active == 0 || candidate == 0 ||
!active->q15Ready() || !candidate->q15Ready())
return false;
/* Real shadow condition: ACTIVE owns FAST first. */
active->q15MemoryInfo(g_r2ActiveShadowQ15);
candidate->q15MemoryInfo(g_r2CandidateShadowQ15);
activeLatencyUs = measureModelQ15Latency(active);
candidateShadowLatencyUs = measureModelQ15Latency(candidate);
if(activeLatencyUs < 0.0f || candidateShadowLatencyUs < 0.0f)
return false;
#if END_BF518_DEPLOYMENT_LATENCY_PATCH
/* TOPPA: create a short maintenance-only "as-if-promoted" placement. */
candidate->releaseQ15();
active->releaseQ15();
deploymentPrepared = candidate->prepareQ15() ? 1 : 0;
if(deploymentPrepared)
{
candidate->q15MemoryInfo(g_r2CandidateDeploymentQ15);
candidateDeploymentLatencyUs = measureModelQ15Latency(candidate);
}
/* Restore the real production/shadow ordering unconditionally. */
candidate->releaseQ15();
activeRestored = active->prepareQ15() ? 1 : 0;
if(activeRestored)
{
active->q15MemoryInfo(g_r2ActiveRestoredQ15);
candidateRestored = candidate->prepareQ15() ? 1 : 0;
if(candidateRestored)
candidate->q15MemoryInfo(g_r2CandidateRestoredQ15);
}
if(!deploymentPrepared || candidateDeploymentLatencyUs < 0.0f ||
!activeRestored || !candidateRestored ||
!active->q15Ready() || !candidate->q15Ready())
return false;
/* A hardware patch must be reversible. Refuse to continue if the temporary
* benchmark changed the real shadow residency we had before entering it. */
if(g_r2ActiveRestoredQ15.mode != g_r2ActiveShadowQ15.mode ||
g_r2ActiveRestoredQ15.fastBytes != g_r2ActiveShadowQ15.fastBytes ||
g_r2ActiveRestoredQ15.normalBytes != g_r2ActiveShadowQ15.normalBytes ||
g_r2CandidateRestoredQ15.mode != g_r2CandidateShadowQ15.mode ||
g_r2CandidateRestoredQ15.fastBytes != g_r2CandidateShadowQ15.fastBytes ||
g_r2CandidateRestoredQ15.normalBytes != g_r2CandidateShadowQ15.normalBytes)
return false;
#else
candidateDeploymentLatencyUs = candidateShadowLatencyUs;
g_r2CandidateDeploymentQ15 = g_r2CandidateShadowQ15;
g_r2ActiveRestoredQ15 = g_r2ActiveShadowQ15;
g_r2CandidateRestoredQ15 = g_r2CandidateShadowQ15;
#endif
return true;
}
/* ------------------------------------------------------------------------- */
/* Real autonomous actions */
/* ------------------------------------------------------------------------- */
static void closeCandidateWork();
static void clearOldTrainingCheckpoints()
{
/* Fixed checkpoint prefix is safe because a new Candidate explicitly retires
* the previous Candidate checkpoint generation before its first sample. */
file.unlink("v022_endurance_training_A.otm");
file.unlink("v022_endurance_training_A.ots");
file.unlink("v022_endurance_training_B.otm");
file.unlink("v022_endurance_training_B.ots");
}
FAST_CODE_2 static unsigned long saturatingIncrement(unsigned long v)
{
return v == 0xFFFFFFFFUL ? v : v + 1UL;
}
FAST_CODE_2 static void clearSimplificationOutcomeMemory()
{
g_state.simplificationBlockedParentModelId = 0UL;
g_state.simplificationBlockedTargetInputs = 0UL;
g_state.simplificationBlockedTargetOutputs = 0UL;
g_state.simplificationBlockedTargetHiddenLayers = 0UL;
g_state.simplificationBlockedTargetHidden0 = 0UL;
g_state.simplificationBlockedTargetHidden1 = 0UL;
g_state.simplificationBlockedTargetHidden2 = 0UL;
g_state.simplificationBlockedTargetHidden3 = 0UL;
g_state.simplificationBlockedOutcome = SIMPLIFY_BLOCK_NONE;
}
FAST_CODE_2 static void rememberSimplificationOutcome(
const otNNModelDescriptor & parent,
const otNNTopology & target,
unsigned long outcome)
{
if(outcome != SIMPLIFY_BLOCK_REJECT && outcome != SIMPLIFY_BLOCK_ROLLBACK)
return;
g_state.simplificationBlockedParentModelId = parent.modelId;
g_state.simplificationBlockedTargetInputs = (unsigned long)target.inputs;
g_state.simplificationBlockedTargetOutputs = (unsigned long)target.outputs;
g_state.simplificationBlockedTargetHiddenLayers = (unsigned long)target.hiddenLayers;
g_state.simplificationBlockedTargetHidden0 = target.hiddenLayers > 0 ? (unsigned long)target.hidden[0] : 0UL;
g_state.simplificationBlockedTargetHidden1 = target.hiddenLayers > 1 ? (unsigned long)target.hidden[1] : 0UL;
g_state.simplificationBlockedTargetHidden2 = target.hiddenLayers > 2 ? (unsigned long)target.hidden[2] : 0UL;
g_state.simplificationBlockedTargetHidden3 = target.hiddenLayers > 3 ? (unsigned long)target.hidden[3] : 0UL;
g_state.simplificationBlockedOutcome = outcome;
}
FAST_CODE_2 static bool simplificationOutcomeBlocks(
const otNNModelDescriptor & parent,
const otNNTopology & target)
{
if(g_state.simplificationBlockedOutcome == SIMPLIFY_BLOCK_NONE) return false;
if(g_state.simplificationBlockedParentModelId != parent.modelId) return false;
if(g_state.simplificationBlockedTargetInputs != (unsigned long)target.inputs ||
g_state.simplificationBlockedTargetOutputs != (unsigned long)target.outputs ||
g_state.simplificationBlockedTargetHiddenLayers != (unsigned long)target.hiddenLayers)
return false;
if(target.hiddenLayers > 0 && g_state.simplificationBlockedTargetHidden0 != (unsigned long)target.hidden[0]) return false;
if(target.hiddenLayers > 1 && g_state.simplificationBlockedTargetHidden1 != (unsigned long)target.hidden[1]) return false;
if(target.hiddenLayers > 2 && g_state.simplificationBlockedTargetHidden2 != (unsigned long)target.hidden[2]) return false;
if(target.hiddenLayers > 3 && g_state.simplificationBlockedTargetHidden3 != (unsigned long)target.hidden[3]) return false;
return true;
}
/* A retry is suppressed only when the reject is evidence about this model/target,
not when validation itself was inconclusive. This mirrors the philosophy of
architecture outcome memory: do not turn missing/technical evidence into a
permanent structural conclusion. */
FAST_CODE_2 static bool simplificationRejectIsConclusive(int reason)
{
switch(reason)
{
case OTNN_DECISION_REJECT_FLOAT_QUALITY:
case OTNN_DECISION_REJECT_Q15_READY:
case OTNN_DECISION_REJECT_Q15_QUALITY:
case OTNN_DECISION_REJECT_Q15_LATENCY:
case OTNN_DECISION_REJECT_COMPLEXITY_DEPTH:
case OTNN_DECISION_REJECT_COMPLEXITY_WIDTH:
case OTNN_DECISION_REJECT_COMPLEXITY_PARAMETERS:
case OTNN_DECISION_REJECT_COMPLEXITY_MACS:
case OTNN_DECISION_REJECT_COMPLEXITY_FLOAT_MEMORY:
case OTNN_DECISION_REJECT_COMPLEXITY_TRAIN_MEMORY:
case OTNN_DECISION_REJECT_COMPLEXITY_Q15_MEMORY:
case OTNN_DECISION_REJECT_COMPLEXITY_Q15_NORMAL:
case OTNN_DECISION_REJECT_COMPLEXITY_FLOAT_LATENCY:
case OTNN_DECISION_REJECT_ACTIVE_DOMINATES:
case OTNN_DECISION_REJECT_EQUIVALENT:
case OTNN_DECISION_REJECT_RELATIVE_COST:
case OTNN_DECISION_REJECT_UNRESOLVED_TRADEOFF:
case OTNN_DECISION_REJECT_DOMINANCE_OTHER:
return true;
case OTNN_DECISION_UNKNOWN:
case OTNN_DECISION_WAIT_SHADOW:
case OTNN_DECISION_REJECT_SAMPLES:
case OTNN_DECISION_REJECT_COMPLEXITY_REPORT:
case OTNN_DECISION_REJECT_DOMINANCE_REPORT:
case OTNN_DECISION_REJECT_SHADOW:
default:
return false;
}
}
FAST_CODE_2 static void resetSimplificationDwell()
{
g_state.simplificationStableSamples = 0UL;
}
FAST_CODE_2 static void noteActiveRoleChanged()
{
g_state.simplificationStableSamples = 0UL;
g_state.simplificationActiveAgeSamples = 0UL;
clearSimplificationOutcomeMemory();
g_previousSimplificationTriggerReason = -1;
}
FAST_CODE_2 static void updateSimplificationCounters(int monitorState)
{
g_state.simplificationActiveAgeSamples =
saturatingIncrement(g_state.simplificationActiveAgeSamples);
if(g_state.simplificationPreviousAttemptKnown)
g_state.simplificationSamplesSinceAttempt =
saturatingIncrement(g_state.simplificationSamplesSinceAttempt);
if(g_controller.phase() == OTNN_AUTONOMY_ACTIVE_STABLE &&
g_monitor.referenceReady() &&
monitorState <= g_simplificationTriggerPolicy.maximumMonitorState)
g_state.simplificationStableSamples =
saturatingIncrement(g_state.simplificationStableSamples);
else
g_state.simplificationStableSamples = 0UL;
}
FAST_CODE_2 static bool prepareSimplificationCandidate(const otNNSimplificationPlan & plan)
{
otTinn * freeModel;
otNNModelDescriptor activeD;
otNNModelDescriptor candidateD;
otTinnWarmStartReport warm;
unsigned long maxId;
if(!plan.valid || !plan.changed) return false;
if(!g_lifecycle.activeDescriptor(activeD)) return false;
freeModel = findFreeModelStorage();
if(freeModel == 0) return false;
memset(&g_gateReport, 0, sizeof(g_gateReport));
maxId = largestRoleModelId();
if(g_state.nextModelId <= maxId) g_state.nextModelId = maxId + 1UL;
otNeuralTrainingSession::makeDescriptor(candidateD,
g_state.nextModelId++, 1UL,
plan.topology);
if(!g_lifecycle.prepareCandidate(freeModel, candidateD, &file)) return false;
memset(&warm, 0, sizeof(warm));
if(g_lifecycle.activeModel() != 0)
freeModel->warmStartFrom(*g_lifecycle.activeModel(), warm);
g_state.simplificationPreviousAttemptKnown = 1UL;
g_state.simplificationSamplesSinceAttempt = 0UL;
g_state.simplificationLifecycleMode = 1UL;
++g_state.simplificationAttempts;
resetSimplificationDwell();
logPrefix("SIMPLIFY");
file.fprintf(g_logFile, "attempt=%lu action=%s saving=%.4f active=",
g_state.simplificationAttempts,
plan.lastAction == OTNN_SIMPLIFY_NARROW_HIDDEN ? "NARROW" :
plan.lastAction == OTNN_SIMPLIFY_REMOVE_DEEPEST ? "REMOVE_DEEPEST" : "UNKNOWN",
plan.activeParameters > 0UL ?
(double)((float)(plan.activeParameters - plan.parameters) /
(float)plan.activeParameters) : 0.0);
logTopologyInline(activeD.topology);
file.fprintf(g_logFile, " candidate=");
logTopologyInline(candidateD.topology);
file.fprintf(g_logFile,
" activeParams=%lu candidateParams=%lu init=%s copied=%lu zeroed=%lu retainedRandom=%lu functionPreserved=%d",
plan.activeParameters, plan.parameters,
warm.mode == OTNN_WARMSTART_EXACT_CLONE ? "CLONE" :
warm.mode == OTNN_WARMSTART_FUNCTION_PRESERVING_WIDEN ? "WIDEN-PRESERVE" :
warm.mode == OTNN_WARMSTART_STRUCTURED_PRUNE_COPY ? "PRUNE-COPY" : "FRESH",
warm.copiedWeights, warm.zeroedWeights, warm.retainedRandomWeights,
warm.functionPreserved);
logEnd(1);
printf("[SIMPLIFY] attempt=%lu candidate=", g_state.simplificationAttempts);
printTopologyInline(candidateD.topology);
printf(" params=%lu/%lu init=%s\n", plan.parameters, plan.activeParameters,
warm.mode == OTNN_WARMSTART_STRUCTURED_PRUNE_COPY ? "PRUNE-COPY" : "FRESH");
if(!commitLifecycle("simplification-candidate-created")) return false;
if(!saveEnduranceState()) return false;
clearOldTrainingCheckpoints();
logSimple("DATASET", "building simplification candidate training dataset", 0);
if(!buildWorldDataset(END_TRAIN_DATASET, 0x251UL)) return false;
logSimple("DATASET", "simplification candidate training dataset ready", 1);
g_trainFramework.close();
g_trainFramework.init(freeModel, &file);
if(!g_trainFramework.dataset(END_TRAIN_DATASET)) return false;
g_trainingSession.close();
if(!g_trainingSession.init(freeModel, &g_trainFramework, &file)) return false;
if(!g_trainingSession.beginExisting(candidateD, END_TRAIN_EPOCHS, 1.0f, 0.99f,
mix32(g_worldSeed ^ candidateD.modelId ^ 0x251UL)))
return false;
g_lastCheckpointSamples = 0UL;
if(!g_controller.resumeTraining()) return false;
return true;
}
FAST_CODE_2 static bool abortSimplificationIfMonitorUnstable(int monitorState)
{
otTinn * c;
otNNModelDescriptor d;
unsigned long id = 0UL;
if(g_state.simplificationLifecycleMode != 1UL) return true;
if(monitorState <= g_simplificationTriggerPolicy.maximumMonitorState) return true;
c = g_lifecycle.candidateModel();
memset(&d, 0, sizeof(d));
if(g_lifecycle.candidateDescriptor(d)) id = d.modelId;
if(c != 0) c->releaseQ15();
g_lifecycle.clearCandidate();
if(c != 0) c->close();
closeCandidateWork();
g_state.simplificationLifecycleMode = 0UL;
++g_state.simplificationRejections;
g_state.simplificationPreviousAttemptKnown = 1UL;
g_state.simplificationSamplesSinceAttempt = 0UL;
resetSimplificationDwell();
if(!g_controller.resumeActiveStable()) return false;
if(monitorState >= OTNN_MONITOR_RETRAIN_REQUIRED)
g_controller.observeMonitorState(monitorState);
logPrefix("SIMPLIFY_ABORT");
file.fprintf(g_logFile,
"candidate=%lu reason=MONITOR_UNSTABLE monitor=%s simplificationRejections=%lu cooldown=%lu nextPhase=%s",
id, monitorName(monitorState), g_state.simplificationRejections,
g_simplificationTriggerPolicy.cooldownSamples,
otNeuralAutonomyController::phaseName(g_controller.phase()));
logEnd(1);
if(!commitLifecycle("simplification-aborted-monitor")) return false;
return saveEnduranceState();
}
FAST_CODE_2 static bool maybeStartSimplification(int window, int monitorState)
{
otNNModelDescriptor activeD;
if(window == OTNN_WINDOW_REALTIME) return true;
if(g_state.simplificationLifecycleMode != 0UL) return true;
if(g_controller.phase() != OTNN_AUTONOMY_ACTIVE_STABLE) return true;
if(!g_lifecycle.activeDescriptor(activeD)) return false;
memset(&g_simplificationPlan, 0, sizeof(g_simplificationPlan));
if(!otNeuralAutonomyController::planSimplerTopology(
activeD.topology, 0UL, g_simplificationPolicy, g_simplificationPlan))
return false;
memset(&g_simplificationTriggerContext, 0, sizeof(g_simplificationTriggerContext));
g_simplificationTriggerContext.autonomyPhase = g_controller.phase();
g_simplificationTriggerContext.monitorState = monitorState;
g_simplificationTriggerContext.hasCandidate = g_lifecycle.hasCandidate() ? 1 : 0;
g_simplificationTriggerContext.hasPrevious = g_lifecycle.hasPrevious() ? 1 : 0;
g_simplificationTriggerContext.stableSamples = g_state.simplificationStableSamples;
g_simplificationTriggerContext.activeAgeSamples = g_state.simplificationActiveAgeSamples;
g_simplificationTriggerContext.previousAttemptKnown =
g_state.simplificationPreviousAttemptKnown ? 1 : 0;
g_simplificationTriggerContext.samplesSincePreviousAttempt =
g_state.simplificationSamplesSinceAttempt;
memset(&g_simplificationTriggerReport, 0, sizeof(g_simplificationTriggerReport));
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
g_simplificationPlan, g_simplificationTriggerContext,
g_simplificationTriggerPolicy, g_simplificationTriggerReport))
return false;
/* SIMMEM1 is deliberately evaluated after the ordinary trigger policy.
The policy first proves that a shrink would otherwise be eligible; only
then do we suppress an exact deterministic target already rejected (or
rolled back) by this same ACTIVE model. */
if(g_simplificationTriggerReport.eligible &&
simplificationOutcomeBlocks(activeD, g_simplificationPlan.topology))
{
g_simplificationTriggerReport.eligible = 0;
g_simplificationTriggerReport.reason = OTNN_SIMPLIFY_TRIGGER_OUTCOME_MEMORY;
}
if(g_simplificationTriggerReport.reason != g_previousSimplificationTriggerReason)
{
logPrefix("SIMPLIFY_TRIGGER");
file.fprintf(g_logFile,
"eligible=%d reason=%s stable=%lu/%lu activeAge=%lu/%lu cooldown=%lu/%lu saving=%.4f/%.4f",
g_simplificationTriggerReport.eligible,
otNeuralAutonomyController::simplificationTriggerReasonName(
g_simplificationTriggerReport.reason),
g_state.simplificationStableSamples,
g_simplificationTriggerPolicy.minimumStableSamples,
g_state.simplificationActiveAgeSamples,
g_simplificationTriggerPolicy.minimumActiveAgeSamples,
g_state.simplificationSamplesSinceAttempt,
g_simplificationTriggerPolicy.cooldownSamples,
(double)g_simplificationTriggerReport.parameterReductionRatio,
(double)g_simplificationTriggerPolicy.minimumParameterReductionRatio);
if(g_simplificationTriggerReport.reason == OTNN_SIMPLIFY_TRIGGER_OUTCOME_MEMORY)
{
file.fprintf(g_logFile, " blockedParent=%lu blockedOutcome=%lu blockedTarget=",
g_state.simplificationBlockedParentModelId,
g_state.simplificationBlockedOutcome);
logTopologyInline(g_simplificationPlan.topology);
}
logEnd(g_simplificationTriggerReport.eligible ? 1 : 0);
g_previousSimplificationTriggerReason = g_simplificationTriggerReport.reason;
}
if(!g_simplificationTriggerReport.eligible) return true;
return prepareSimplificationCandidate(g_simplificationPlan);
}
FAST_CODE_2 static bool prepareFreshCandidate()
{
otTinn * freeModel;
otNNModelDescriptor activeD;
otNNModelDescriptor candidateD;
otNNArchitecturePlan plan;
otTinnWarmStartReport warm;
unsigned long maxId;
if(!g_lifecycle.activeDescriptor(activeD)) return false;
freeModel = findFreeModelStorage();
if(freeModel == 0) return false;
if(!otNeuralAutonomyController::planCandidateTopologyWithHistory(
activeD.topology,
g_state.architectureNextStage,
g_state.architectureFailures,
g_state.architectureParameterCeiling,
architectureBlockedMask(g_state),
g_architecturePolicy, plan) ||
!plan.valid)
return false;
g_state.adaptationArchitectureStage = (unsigned long)plan.stage;
g_state.architectureSaturated = plan.saturated ? 1UL : 0UL;
markArchitectureAttempt(g_state.adaptationArchitectureStage);
memset(&g_gateReport, 0, sizeof(g_gateReport));
maxId = largestRoleModelId();
if(g_state.nextModelId <= maxId) g_state.nextModelId = maxId + 1UL;
otNeuralTrainingSession::makeDescriptor(candidateD,
g_state.nextModelId++, 1UL,
plan.topology);
if(!g_lifecycle.prepareCandidate(freeModel, candidateD, &file)) return false;
memset(&warm, 0, sizeof(warm));
if(g_lifecycle.activeModel() != 0)
freeModel->warmStartFrom(*g_lifecycle.activeModel(), warm);
logPrefix("ARCH");
file.fprintf(g_logFile, "failures=%lu requested=%d stage=%d skipped=%d changed=%d resourceLimited=%d historyLimited=%d historySkipped=%d saturated=%d cap=%lu params=%lu attemptedMask=0x%03lX outcomeBits=0x%05lX active=",
g_state.architectureFailures, plan.requestedStage, plan.stage,
plan.skippedStages, plan.changed, plan.resourceLimited, plan.historyLimited,
plan.historySkippedStages, plan.saturated,
plan.effectiveMaximumParameters, plan.parameters,
g_state.architectureAttemptedMask, g_state.architectureOutcomeBits);
logTopologyInline(activeD.topology);
file.fprintf(g_logFile, " candidate=");
logTopologyInline(candidateD.topology);
file.fprintf(g_logFile, " init=%s copied=%lu zeroed=%lu retainedRandom=%lu functionPreserved=%d",
warm.mode == OTNN_WARMSTART_EXACT_CLONE ? "CLONE" :
warm.mode == OTNN_WARMSTART_FUNCTION_PRESERVING_WIDEN ? "WIDEN-PRESERVE" :
warm.mode == OTNN_WARMSTART_STRUCTURED_PRUNE_COPY ? "PRUNE-COPY" : "FRESH",
warm.copiedWeights, warm.zeroedWeights, warm.retainedRandomWeights,
warm.functionPreserved);
logEnd(1);
printf("[ARCH] failures=%lu requested=%d stage=%d candidate=",
g_state.architectureFailures, plan.requestedStage, plan.stage);
printTopologyInline(candidateD.topology);
printf(" params=%lu cap=%lu%s%s%s init=%s\n", plan.parameters,
plan.effectiveMaximumParameters,
plan.resourceLimited ? " RESOURCE-AWARE" : "",
plan.historyLimited ? " HISTORY-SKIP" : "",
plan.saturated ? " SATURATED" : "",
warm.mode == OTNN_WARMSTART_EXACT_CLONE ? "CLONE" :
warm.mode == OTNN_WARMSTART_FUNCTION_PRESERVING_WIDEN ? "WIDEN-PRESERVE" : "FRESH");
logPrefix("CANDIDATE");
file.fprintf(g_logFile, "create id=%lu/r%lu topology=",
candidateD.modelId, candidateD.revision);
logTopologyInline(candidateD.topology);
file.fprintf(g_logFile, " archFailures=%lu archStage=%lu resourceCap=%lu saturated=%lu attemptedMask=0x%03lX outcomeBits=0x%05lX init=%s functionPreserved=%d worldCycle=%lu local=%lu",
g_state.architectureFailures, g_state.adaptationArchitectureStage,
g_state.architectureParameterCeiling, g_state.architectureSaturated,
g_state.architectureAttemptedMask, g_state.architectureOutcomeBits,
warm.mode == OTNN_WARMSTART_EXACT_CLONE ? "CLONE" :
warm.mode == OTNN_WARMSTART_FUNCTION_PRESERVING_WIDEN ? "WIDEN-PRESERVE" :
warm.mode == OTNN_WARMSTART_STRUCTURED_PRUNE_COPY ? "PRUNE-COPY" : "FRESH",
warm.functionPreserved, g_state.worldCycle, g_state.worldLocalTick);
logEnd(1);
/* Persist the role before expensive training starts. A power loss can then
* recover the Candidate identity and the independent training A/B checkpoint. */
if(!commitLifecycle("candidate-created")) return false;
if(!saveEnduranceState()) return false;
clearOldTrainingCheckpoints();
logSimple("DATASET", "building candidate training dataset", 0);
if(!buildWorldDataset(END_TRAIN_DATASET, 0x135UL)) return false;
logSimple("DATASET", "candidate training dataset ready", 1);
g_trainFramework.close();
g_trainFramework.init(freeModel, &file);
if(!g_trainFramework.dataset(END_TRAIN_DATASET)) return false;
g_trainingSession.close();
if(!g_trainingSession.init(freeModel, &g_trainFramework, &file)) return false;
if(!g_trainingSession.beginExisting(candidateD, END_TRAIN_EPOCHS, 1.0f, 0.99f,
mix32(g_worldSeed ^ candidateD.modelId)))
return false;
g_lastCheckpointSamples = 0UL;
return true;
}
FAST_CODE_2 static bool resumeCandidateTrainingIfPossible()
{
otTinn * c = g_lifecycle.candidateModel();
if(c == 0 || g_lifecycle.hasPrevious()) return false;
g_trainFramework.close();
g_trainFramework.init(c, &file);
if(!g_trainFramework.dataset(END_TRAIN_DATASET)) return false;
g_trainingSession.close();
if(!g_trainingSession.init(c, &g_trainFramework, &file)) return false;
if(!g_trainingSession.loadLatestCheckpoint(END_TRAINING_PREFIX)) return false;
{
otNNTrainingProgress p;
g_trainingSession.progress(p);
g_lastCheckpointSamples = p.samplesTrained;
if(p.state == OTNN_TRAINING_PAUSED)
{
if(!g_trainingSession.resume()) return false;
g_trainingSession.progress(p);
}
else if(p.state != OTNN_TRAINING_COMPLETE)
return false;
logPrefix("TRAIN");
file.fprintf(g_logFile,
"resume checkpointSeq=%lu epoch=%lu sample=%lu trained=%lu trainingState=%d session=%s",
p.checkpointSequence, p.currentEpoch, p.sampleIndex, p.samplesTrained,
p.state, p.state == OTNN_TRAINING_COMPLETE ? "COMPLETE" : "RUNNING");
logEnd(1);
}
return true;
}
static bool trainCandidateBlock()
{
otNNTrainingProgress p;
unsigned long done = g_trainingSession.trainSamples(END_TRAIN_BLOCK_SAMPLES);
g_trainingSession.progress(p);
if(done == 0UL && p.state == OTNN_TRAINING_ERROR) return false;
if(p.samplesTrained >= g_lastCheckpointSamples + END_CHECKPOINT_PERIOD ||
p.state == OTNN_TRAINING_COMPLETE)
{
if(!g_trainingSession.saveCheckpoint(END_TRAINING_PREFIX)) return false;
g_lastCheckpointSamples = p.samplesTrained;
++g_checkpointsTotal;
logPrefix("CHECKPOINT");
file.fprintf(g_logFile, "trained=%lu epoch=%lu sample=%lu state=%d count=%lu",
p.samplesTrained, p.currentEpoch, p.sampleIndex, p.state, g_checkpointsTotal);
logEnd(1);
if(!saveEnduranceState()) return false;
}
return true;
}
static bool validateCandidateNow()
{
float activeLatency;
float candidateShadowLatency;
float candidateDeploymentLatency;
otNNModelDescriptor activeDescriptor;
otNNModelDescriptor candidateDescriptor;
logSimple("DATASET", "building current-world validation dataset", 0);
if(!buildWorldDataset(END_VALIDATION_DATASET, 0x5A5UL)) return false;
logSimple("DATASET", "current-world validation dataset ready", 1);
g_validationFramework.close();
g_validationFramework.init(g_lifecycle.activeModel(), &file);
if(!g_validationFramework.dataset(END_VALIDATION_DATASET)) return false;
memset(&g_validationReport, 0, sizeof(g_validationReport));
if(!g_lifecycle.validateCandidate(&g_validationFramework, g_validationReport, 1, 0, 0))
return false;
activeLatency = -1.0f;
candidateShadowLatency = -1.0f;
candidateDeploymentLatency = -1.0f;
if(g_validationReport.active.q15Prepared &&
g_validationReport.candidate.q15Prepared)
{
if(!measureBF518DeploymentLatencyPatch(activeLatency,
candidateShadowLatency,
candidateDeploymentLatency))
return false;
/* Refresh the report's memory snapshots after restoring real shadow
* placement. Accuracy/error values remain those already evaluated. */
g_lifecycle.activeModel()->q15MemoryInfo(g_validationReport.active.q15Memory);
g_lifecycle.candidateModel()->q15MemoryInfo(g_validationReport.candidate.q15Memory);
logPrefix("HW_PATCH");
file.fprintf(g_logFile,
"TOPPA_BF518 latencyNormalization=DEPLOYMENT candidateActuation=0 activeShadow=%.3f candidateShadow=%.3f candidateDeployment=%.3f shadowModes[A=%s C=%s] deploymentCandidateMode=%s restoredModes[A=%s C=%s] deploymentFast=%lu deploymentNormal=%lu",
(double)activeLatency, (double)candidateShadowLatency,
(double)candidateDeploymentLatency,
q15ModeName(g_r2ActiveShadowQ15.mode),
q15ModeName(g_r2CandidateShadowQ15.mode),
q15ModeName(g_r2CandidateDeploymentQ15.mode),
q15ModeName(g_r2ActiveRestoredQ15.mode),
q15ModeName(g_r2CandidateRestoredQ15.mode),
g_r2CandidateDeploymentQ15.fastBytes,
g_r2CandidateDeploymentQ15.normalBytes);
logEnd(1);
}
else
{
if(g_validationReport.active.q15Prepared)
activeLatency = measureModelQ15Latency(g_lifecycle.activeModel());
if(g_validationReport.candidate.q15Prepared)
{
candidateShadowLatency = measureModelQ15Latency(g_lifecycle.candidateModel());
candidateDeploymentLatency = candidateShadowLatency;
}
}
memset(&g_activeExecution, 0, sizeof(g_activeExecution));
if(activeLatency >= 0.0f)
{
g_activeExecution.q15LatencyValid = 1;
g_activeExecution.q15LatencyUs = activeLatency;
}
memset(&g_candidateExecution, 0, sizeof(g_candidateExecution));
if(candidateDeploymentLatency >= 0.0f)
{
g_candidateExecution.q15LatencyValid = 1;
/* TOPPA BF518: promotion gates must use as-if-promoted deployment
* latency, never the memory-handicapped shadow latency. */
g_candidateExecution.q15LatencyUs = candidateDeploymentLatency;
}
memset(&activeDescriptor, 0, sizeof(activeDescriptor));
memset(&candidateDescriptor, 0, sizeof(candidateDescriptor));
memset(&g_activeComplexity, 0, sizeof(g_activeComplexity));
memset(&g_candidateComplexity, 0, sizeof(g_candidateComplexity));
if(!g_lifecycle.activeDescriptor(activeDescriptor) ||
!g_lifecycle.candidateDescriptor(candidateDescriptor) ||
!otNeuralModelLifecycle::buildComplexityReport(
g_lifecycle.activeModel(), activeDescriptor,
&g_activeExecution, g_activeComplexity) ||
!otNeuralModelLifecycle::buildComplexityReport(
g_lifecycle.candidateModel(), candidateDescriptor,
&g_candidateExecution, g_candidateComplexity))
return false;
memset(&g_activeSignature, 0, sizeof(g_activeSignature));
memset(&g_candidateSignature, 0, sizeof(g_candidateSignature));
if(!otNeuralModelLifecycle::buildModelPerformanceSignature(
activeDescriptor,
g_validationReport.active,
g_activeComplexity,
0,
1,
g_state.simplificationActiveAgeSamples,
g_state.simplificationStableSamples,
g_activeSignature) ||
!otNeuralModelLifecycle::buildModelPerformanceSignature(
candidateDescriptor,
g_validationReport.candidate,
g_candidateComplexity,
g_r2CandidateDeploymentQ15.ready ? &g_r2CandidateDeploymentQ15 : 0,
0,
0UL,
0UL,
g_candidateSignature))
return false;
logPrefix("VALIDATE");
file.fprintf(g_logFile,
"activeAcc=%.3f candidateAcc=%.3f activeErr=%.7f candidateErr=%.7f q15Active=%.3f q15Candidate=%.3f activeDeploymentLatency=%.3f candidateShadowLatency=%.3f candidateDeploymentLatency=%.3f promotionLatencySource=DEPLOYMENT_HW_PATCH",
(double)g_validationReport.active.accuracyPercent,
(double)g_validationReport.candidate.accuracyPercent,
(double)g_validationReport.active.meanAbsError,
(double)g_validationReport.candidate.meanAbsError,
(double)g_validationReport.active.q15AccuracyPercent,
(double)g_validationReport.candidate.q15AccuracyPercent,
(double)activeLatency, (double)candidateShadowLatency,
(double)candidateDeploymentLatency);
logEnd(1);
logModelPerformanceSignature("ACTIVE", g_activeSignature);
logModelPerformanceSignature("CANDIDATE", g_candidateSignature);
memset(&g_improvementReport, 0, sizeof(g_improvementReport));
if(!otNeuralModelLifecycle::evaluateSignatureMeaningfulImprovement(
g_activeSignature, g_candidateSignature,
g_improvementPolicy, g_improvementReport))
return false;
logPrefix("IMPROVEMENT");
file.fprintf(g_logFile,
"floatAccAvail=%d floatAccGain=%.4f min=%.4f meaningful=%d floatErrAvail=%d floatErrReduction=%.5f min=%.5f meaningful=%d q15AccAvail=%d q15AccGain=%.4f min=%.4f meaningful=%d q15ErrAvail=%d q15ErrReduction=%.5f min=%.5f meaningful=%d feedsDominance=1",
g_improvementReport.floatAccuracyAvailable,
(double)g_improvementReport.floatAccuracyGainPoints,
(double)g_improvementPolicy.minimumFloatAccuracyGainPoints,
g_improvementReport.floatAccuracyMeaningful,
g_improvementReport.floatMeanErrorAvailable,
(double)g_improvementReport.floatMeanErrorReductionRatio,
(double)g_improvementPolicy.minimumFloatMeanErrorReductionRatio,
g_improvementReport.floatMeanErrorMeaningful,
g_improvementReport.q15AccuracyAvailable,
(double)g_improvementReport.q15AccuracyGainPoints,
(double)g_improvementPolicy.minimumQ15AccuracyGainPoints,
g_improvementReport.q15AccuracyMeaningful,
g_improvementReport.q15MeanErrorAvailable,
(double)g_improvementReport.q15MeanErrorReductionRatio,
(double)g_improvementPolicy.minimumQ15MeanErrorReductionRatio,
g_improvementReport.q15MeanErrorMeaningful);
logEnd(1);
memset(&g_comparisonReport, 0, sizeof(g_comparisonReport));
if(!otNeuralModelLifecycle::comparePerformanceSignatures(
g_activeSignature, g_candidateSignature,
g_comparisonPolicy, g_comparisonReport))
return false;
memset(&g_dominanceReport, 0, sizeof(g_dominanceReport));
if(!otNeuralModelLifecycle::evaluateSignatureDominance(
g_comparisonReport, g_improvementReport,
g_activeSignature, g_candidateSignature,
g_dominancePolicy, g_dominanceReport))
return false;
logPrefix("COMPLEXITY");
file.fprintf(g_logFile,
"activeParams=%lu candidateParams=%lu activeMACs=%lu candidateMACs=%lu activeFloatBytes=%lu candidateFloatBytes=%lu activeWorkspace=%lu candidateWorkspace=%lu activeQ15Bytes=%lu candidateQ15Bytes=%lu activeQ15Latency=%.3f candidateQ15Latency=%.3f",
g_activeComplexity.parameters, g_candidateComplexity.parameters,
g_activeComplexity.macsPerInference, g_candidateComplexity.macsPerInference,
g_activeComplexity.floatRuntimeBytes, g_candidateComplexity.floatRuntimeBytes,
g_activeComplexity.trainingWorkspaceBytes, g_candidateComplexity.trainingWorkspaceBytes,
g_activeComplexity.q15RuntimeBytes, g_candidateComplexity.q15RuntimeBytes,
(double)g_activeComplexity.q15LatencyUs,
(double)g_candidateComplexity.q15LatencyUs);
logEnd(1);
logPrefix("DOMINANCE");
file.fprintf(g_logFile,
"qualityCandidateBetter=%d qualityActiveBetter=%d meaningfulGain=%d costCandidateLower=%d costActiveLower=%d sameOrLowerCost=%d boundedExtraCost=%d candidatePareto=%d activePareto=%d boundedTradeoff=%d equivalent=%d unresolved=%d paramInc=%.4f macInc=%.4f floatBytesInc=%.4f workspaceInc=%.4f q15BytesInc=%.4f q15LatencyInc=%.4f promotionEvidence=1 policyInput=SIGNATURE2",
g_dominanceReport.qualityCandidateBetter,
g_dominanceReport.qualityActiveBetter,
g_dominanceReport.meaningfulQualityGain,
g_dominanceReport.costCandidateLower,
g_dominanceReport.costActiveLower,
g_dominanceReport.sameOrLowerCost,
g_dominanceReport.boundedExtraCost,
g_dominanceReport.candidateParetoDominates,
g_dominanceReport.activeParetoDominates,
g_dominanceReport.candidateBoundedTradeoff,
g_dominanceReport.equivalent,
g_dominanceReport.unresolvedTradeoff,
(double)g_dominanceReport.parameters.candidateIncreaseRatio,
(double)g_dominanceReport.macs.candidateIncreaseRatio,
(double)g_dominanceReport.floatRuntimeBytes.candidateIncreaseRatio,
(double)g_dominanceReport.trainingWorkspaceBytes.candidateIncreaseRatio,
(double)g_dominanceReport.q15RuntimeBytes.candidateIncreaseRatio,
(double)g_dominanceReport.q15LatencyUs.candidateIncreaseRatio);
logEnd(1);
return true;
}
static bool shadowCandidateNow()
{
if(!g_validationFramework.valid()) return false;
memset(&g_shadowReport, 0, sizeof(g_shadowReport));
if(!g_lifecycle.shadowCandidate(&g_validationFramework, g_shadowReport, 1, 0, 0))
return false;
logPrefix("SHADOW");
file.fprintf(g_logFile,
"samples=%lu disagreements=%lu agreement=%.3f meanDelta=%.7f maxDelta=%.7f authority=%d",
g_shadowReport.samples, g_shadowReport.classDisagreements,
(double)g_shadowReport.classAgreementPercent,
(double)g_shadowReport.meanAbsOutputDelta,
(double)g_shadowReport.maxAbsOutputDelta,
g_shadowReport.candidateAuthority);
logEnd(1);
return true;
}
static void closeCandidateWork()
{
g_trainingSession.close();
g_trainFramework.close();
g_validationFramework.close();
}
FAST_CODE_2 static bool rejectCandidateNow()
{
otTinn * c = g_lifecycle.candidateModel();
otNNModelDescriptor d;
otNNModelDescriptor activeD;
unsigned long id = 0UL;
int haveActiveD = 0;
const char * archOutcome = "neutral";
const int complexityResourceFailure = g_gateReport.valid &&
g_gateReport.complexity.valid && g_gateReport.complexity.reportGate &&
!g_gateReport.complexity.eligible;
const int resourceFailure = g_gateReport.valid &&
(!g_gateReport.q15ReadyGate || !g_gateReport.q15LatencyGate ||
complexityResourceFailure);
const int qualityFailure = g_gateReport.valid &&
g_gateReport.sampleGate && g_gateReport.q15ReadyGate &&
g_gateReport.q15LatencyGate && g_gateReport.complexity.eligible &&
(!g_gateReport.floatQualityGate || !g_gateReport.q15QualityGate);
const int dominanceFailure = g_gateReport.valid &&
g_gateReport.sampleGate && g_gateReport.floatQualityGate &&
g_gateReport.q15QualityGate && g_gateReport.q15ReadyGate &&
g_gateReport.q15LatencyGate && g_gateReport.complexity.eligible &&
g_gateReport.dominanceApplied && g_gateReport.dominanceReportGate &&
!g_gateReport.dominanceGate;
const int dominanceRelativeCostFailure = dominanceFailure &&
g_dominanceReport.valid && g_dominanceReport.unresolvedTradeoff &&
g_dominanceReport.meaningfulQualityGain &&
!g_dominanceReport.boundedExtraCost;
const int dominanceBenefitFailure = dominanceFailure &&
!dominanceRelativeCostFailure;
memset(&d, 0, sizeof(d));
memset(&activeD, 0, sizeof(activeD));
haveActiveD = g_lifecycle.activeDescriptor(activeD) ? 1 : 0;
if(g_lifecycle.candidateDescriptor(d)) id = d.modelId;
if(c != 0) c->releaseQ15();
g_lifecycle.clearCandidate();
if(c != 0) c->close();
closeCandidateWork();
++g_rejectionsTotal;
if(g_state.simplificationLifecycleMode == 1UL)
{
++g_state.simplificationRejections;
g_state.simplificationLifecycleMode = 0UL;
g_state.simplificationPreviousAttemptKnown = 1UL;
g_state.simplificationSamplesSinceAttempt = 0UL;
resetSimplificationDwell();
if(haveActiveD && id != 0UL &&
simplificationRejectIsConclusive(g_decisionTrace.reason))
rememberSimplificationOutcome(activeD, d.topology, SIMPLIFY_BLOCK_REJECT);
logPrefix("SIMPLIFY_REJECT");
file.fprintf(g_logFile,
"candidate=%lu total=%lu simplificationRejections=%lu decision=%s activePreserved=1 cooldown=%lu stableReset=1 archStateUntouched=1 dAcc=%.4f dParams=%ld",
id, g_rejectionsTotal, g_state.simplificationRejections,
otNeuralAutonomyController::promotionDecisionReasonName(g_decisionTrace.reason),
g_simplificationTriggerPolicy.cooldownSamples,
(double)g_decisionTrace.floatAccuracyDeltaPoints,
g_decisionTrace.parameterDelta);
if(g_state.simplificationBlockedOutcome != SIMPLIFY_BLOCK_NONE &&
g_state.simplificationBlockedParentModelId == activeD.modelId)
{
file.fprintf(g_logFile, " outcomeMemory[parent=%lu target=",
g_state.simplificationBlockedParentModelId);
logTopologyInline(d.topology);
file.fprintf(g_logFile, " outcome=REJECT]");
}
else
file.fprintf(g_logFile, " outcomeMemory=UNCHANGED_INCONCLUSIVE");
logEnd(1);
if(!commitLifecycle("simplification-candidate-rejected")) return false;
return saveEnduranceState();
}
if(qualityFailure)
{
++g_state.architectureFailures;
markArchitectureOutcome(g_state.adaptationArchitectureStage, 1UL); /* quality */
g_state.architectureNextStage =
clampArchitectureStage(g_state.adaptationArchitectureStage + 1UL);
if(g_state.adaptationArchitectureStage >= 9UL)
g_state.architectureSaturated = 1UL;
archOutcome = "quality-advance";
}
else if(resourceFailure)
{
unsigned long candidateParameters = 0UL;
if(g_validationReport.valid && g_validationReport.candidate.valid)
candidateParameters = g_validationReport.candidate.parameterCount;
/* Learn an empirical upper envelope from the rejected deployment shape.
Quality failures are NOT incremented. The stage cursor moves forward so
the deterministic planner may try a later, narrower/deeper shape. */
markArchitectureOutcome(g_state.adaptationArchitectureStage, 2UL); /* resource */
if(candidateParameters > 1UL)
{
const unsigned long learned = candidateParameters - 1UL;
if(g_state.architectureParameterCeiling == 0UL ||
learned < g_state.architectureParameterCeiling)
g_state.architectureParameterCeiling = learned;
}
g_state.architectureNextStage =
clampArchitectureStage(g_state.adaptationArchitectureStage + 1UL);
archOutcome = "resource-learn+skip";
}
else if(dominanceRelativeCostFailure)
{
/* Step 5: the Candidate really improved quality, but only at an
unjustified relative complexity cost. Treat this as a conclusive
complexity/resource outcome for this deterministic stage, but do NOT
tighten the absolute parameter ceiling: the Candidate still fit the
target, it simply was not worth the relative cost versus ACTIVE. */
markArchitectureOutcome(g_state.adaptationArchitectureStage, 2UL);
g_state.architectureNextStage =
clampArchitectureStage(g_state.adaptationArchitectureStage + 1UL);
if(g_state.adaptationArchitectureStage >= 9UL)
g_state.architectureSaturated = 1UL;
archOutcome = "dominance-cost-skip";
}
else if(dominanceBenefitFailure)
{
/* ACTIVE-dominant, equivalent, or otherwise unresolved without a
meaningful bounded benefit: this architecture failed to justify
promotion. Reuse outcome code 01 as quality/benefit failure; the
persisted two-bit format remains backward compatible. */
++g_state.architectureFailures;
markArchitectureOutcome(g_state.adaptationArchitectureStage, 1UL);
g_state.architectureNextStage =
clampArchitectureStage(g_state.adaptationArchitectureStage + 1UL);
if(g_state.adaptationArchitectureStage >= 9UL)
g_state.architectureSaturated = 1UL;
archOutcome = "dominance-benefit-advance";
}
else
{
/* Insufficient samples, missing dominance evidence or a technical shadow
condition says nothing conclusive about model capacity/value. Retry the
same deterministic architecture stage. */
g_state.architectureNextStage = g_state.adaptationArchitectureStage;
}
g_state.adaptationArchitectureStage = 0UL;
g_retryCooldown = END_RETRY_COOLDOWN_SAMPLES;
logPrefix("REJECT");
file.fprintf(g_logFile,
"candidate=%lu cooldown=%lu total=%lu archFailures=%lu nextStage=%lu resourceCap=%lu saturated=%lu attemptedMask=0x%03lX outcomeBits=0x%05lX archOutcome=%s decision=%s dAcc=%.4f dParams=%ld paramInc=%.4f dQ15Latency=%.4f gates[sample=%d float=%d q15=%d ready=%d latency=%d complexity=%d dominanceApplied=%d dominanceReport=%d dominance=%d shadow=%d]",
id, g_retryCooldown, g_rejectionsTotal, g_state.architectureFailures,
g_state.architectureNextStage, g_state.architectureParameterCeiling,
g_state.architectureSaturated, g_state.architectureAttemptedMask,
g_state.architectureOutcomeBits, archOutcome,
otNeuralAutonomyController::promotionDecisionReasonName(g_decisionTrace.reason),
(double)g_decisionTrace.floatAccuracyDeltaPoints,
g_decisionTrace.parameterDelta, (double)g_decisionTrace.parameterIncreaseRatio,
(double)g_decisionTrace.q15LatencyDeltaUs,
g_gateReport.sampleGate, g_gateReport.floatQualityGate,
g_gateReport.q15QualityGate, g_gateReport.q15ReadyGate,
g_gateReport.q15LatencyGate, g_gateReport.complexity.eligible,
g_gateReport.dominanceApplied, g_gateReport.dominanceReportGate,
g_gateReport.dominanceGate, g_gateReport.shadowGate);
logEnd(1);
if(!commitLifecycle("candidate-rejected")) return false;
return saveEnduranceState();
}
FAST_CODE_2 static bool promoteCandidateNow()
{
otNNModelDescriptor before;
/* Step 5 defense-in-depth: the controller should only request promotion
after validation + shadow have passed, but never let a stale/direct call
bypass the now-mandatory production dominance decision. */
if(!g_gateReport.valid || !g_gateReport.eligible ||
!g_gateReport.dominanceApplied || !g_gateReport.dominanceReportGate ||
!g_gateReport.dominanceGate)
return false;
memset(&g_promotionReport, 0, sizeof(g_promotionReport));
if(!g_lifecycle.candidateDescriptor(before)) return false;
if(!g_lifecycle.promoteCandidate(g_promotionReport)) return false;
++g_promotionsTotal;
if(g_state.simplificationLifecycleMode == 1UL)
{
g_state.simplificationLifecycleMode = 2UL;
++g_state.simplificationPromotions;
}
noteActiveRoleChanged();
g_probationGoodSamples = 0UL;
g_monitor.reset();
closeCandidateWork();
logPrefix("PROMOTE");
file.fprintf(g_logFile,
"newActive=%lu/r%lu previous=%lu/r%lu total=%lu decision=%s dAcc=%.4f dParams=%ld paramInc=%.4f dQ15Latency=%.4f",
g_promotionReport.activeAfter.modelId,
g_promotionReport.activeAfter.revision,
g_promotionReport.previousAfter.modelId,
g_promotionReport.previousAfter.revision,
g_promotionsTotal,
otNeuralAutonomyController::promotionDecisionReasonName(g_decisionTrace.reason),
(double)g_decisionTrace.floatAccuracyDeltaPoints,
g_decisionTrace.parameterDelta, (double)g_decisionTrace.parameterIncreaseRatio,
(double)g_decisionTrace.q15LatencyDeltaUs);
logEnd(1);
return saveEnduranceState();
}
FAST_CODE_2 static bool rollbackNow()
{
otTinn * failed;
otNNModelDescriptor failedD;
unsigned long failedId = 0UL;
const int simplificationRollback =
g_state.simplificationLifecycleMode == 2UL ? 1 : 0;
memset(&g_rollbackReport, 0, sizeof(g_rollbackReport));
if(!g_lifecycle.rollbackPrevious(g_rollbackReport)) return false;
++g_rollbacksTotal;
if(simplificationRollback)
{
g_state.simplificationLifecycleMode = 0UL;
++g_state.simplificationRollbacks;
g_state.simplificationPreviousAttemptKnown = 1UL;
g_state.simplificationSamplesSinceAttempt = 0UL;
noteActiveRoleChanged();
rememberSimplificationOutcome(g_rollbackReport.activeAfter,
g_rollbackReport.candidateAfter.topology,
SIMPLIFY_BLOCK_ROLLBACK);
}
else
{
++g_state.architectureFailures;
markArchitectureOutcome(g_state.adaptationArchitectureStage, 3UL);
g_state.architectureNextStage =
clampArchitectureStage(g_state.adaptationArchitectureStage + 1UL);
if(g_state.adaptationArchitectureStage >= 9UL)
g_state.architectureSaturated = 1UL;
noteActiveRoleChanged();
}
failed = g_lifecycle.candidateModel();
if(g_lifecycle.candidateDescriptor(failedD)) failedId = failedD.modelId;
if(failed != 0) failed->releaseQ15();
g_lifecycle.clearCandidate();
if(failed != 0) failed->close();
if(g_lifecycle.activeModel() == 0 || !g_lifecycle.activeModel()->prepareQ15())
return false;
closeCandidateWork();
g_monitor.reset();
g_probationGoodSamples = 0UL;
logPrefix(simplificationRollback ? "SIMPLIFY_ROLLBACK" : "ROLLBACK");
file.fprintf(g_logFile,
"restored=%lu/r%lu failedCandidate=%lu activeQ15=rebuild-ok total=%lu archFailures=%lu failedStage=%lu nextStage=%lu resourceCap=%lu saturated=%lu attemptedMask=0x%03lX outcomeBits=0x%05lX simplificationRollback=%d simplificationRollbacks=%lu",
g_rollbackReport.activeAfter.modelId,
g_rollbackReport.activeAfter.revision,
failedId, g_rollbacksTotal, g_state.architectureFailures,
g_state.adaptationArchitectureStage, g_state.architectureNextStage,
g_state.architectureParameterCeiling, g_state.architectureSaturated,
g_state.architectureAttemptedMask, g_state.architectureOutcomeBits,
simplificationRollback, g_state.simplificationRollbacks);
logEnd(1);
if(!simplificationRollback) g_state.adaptationArchitectureStage = 0UL;
return saveEnduranceState();
}
FAST_CODE_2 static bool finalizeProbationIfReady(int window)
{
otTinn * oldPrevious;
otTinn * active;
otTinnQ15MemoryInfo qi;
if(g_controller.phase() != OTNN_AUTONOMY_PROBATION) return true;
if(g_probationGoodSamples < END_PROBATION_GOOD_SAMPLES) return true;
if(window == OTNN_WINDOW_REALTIME) return true;
if(!g_lifecycle.hasPrevious()) return false;
oldPrevious = g_lifecycle.previousModel();
active = g_lifecycle.activeModel();
if(oldPrevious != 0) oldPrevious->releaseQ15();
if(!g_lifecycle.retirePrevious()) return false;
if(oldPrevious != 0) oldPrevious->close();
/* The promoted model was often MIXED while PREVIOUS occupied FAST memory.
* Once probation succeeds, rebuild ACTIVE so it can reclaim the fastest
* placement available on this boot. */
if(active == 0) return false;
active->releaseQ15();
if(!active->prepareQ15()) return false;
memset(&qi, 0, sizeof(qi));
active->q15MemoryInfo(qi);
{
const unsigned long oldFailures = g_state.architectureFailures;
const unsigned long oldAttemptedMask = g_state.architectureAttemptedMask;
const unsigned long oldOutcomeBits = g_state.architectureOutcomeBits;
const int simplificationAccepted =
g_state.simplificationLifecycleMode == 2UL ? 1 : 0;
if(!g_controller.acceptProbation()) return false;
if(!commitLifecycle(simplificationAccepted ?
"simplification-probation-accepted" :
"probation-accepted")) return false;
g_controller.markCatalogCommitted();
if(simplificationAccepted) g_state.simplificationLifecycleMode = 0UL;
g_probationGoodSamples = 0UL;
g_state.architectureFailures = 0UL;
g_state.architectureNextStage = 0UL;
g_state.architectureParameterCeiling = 0UL;
g_state.adaptationArchitectureStage = 0UL;
g_state.architectureSaturated = 0UL;
g_state.architectureAttemptedMask = 0UL;
g_state.architectureOutcomeBits = 0UL;
logPrefix("PROBATION");
file.fprintf(g_logFile, "accepted previous=retired activeQ15=%s fast=%lu normal=%lu archFailures=%lu->0 resourceEnvelope=reset attemptedMask=0x%03lX->0 outcomeBits=0x%05lX->0 simplificationAccepted=%d simplificationPromotions=%lu",
q15ModeName(qi.mode), qi.fastBytes, qi.normalBytes, oldFailures,
oldAttemptedMask, oldOutcomeBits, simplificationAccepted,
g_state.simplificationPromotions);
}
logEnd(1);
printSerialEvent("PROBATION ACCEPTED - PREVIOUS RETIRED");
return saveEnduranceState();
}
static bool processAutonomyAction(int window)
{
int action;
int trainingState = OTNN_TRAINING_EMPTY;
otNNTrainingProgress tp;
bool ok = true;
memset(&tp, 0, sizeof(tp));
g_trainingSession.progress(tp);
trainingState = tp.state;
action = g_controller.nextAction(g_lifecycle, trainingState);
if(action == OTNN_AUTONOMY_ACTION_NONE) return true;
const int simplificationAction =
g_state.simplificationLifecycleMode != 0UL ? 1 : 0;
logPrefix("ACTION");
file.fprintf(g_logFile, "phase=%s window=%s action=%s trainingState=%d",
otNeuralAutonomyController::phaseName(g_controller.phase()),
otNeuralAutonomyController::windowName(window),
otNeuralAutonomyController::actionName(action), trainingState);
logEnd(0);
switch(action)
{
case OTNN_AUTONOMY_ACTION_CREATE_CANDIDATE:
ok = prepareFreshCandidate();
break;
case OTNN_AUTONOMY_ACTION_TRAIN_CANDIDATE:
ok = trainCandidateBlock();
break;
case OTNN_AUTONOMY_ACTION_VALIDATE_CANDIDATE:
ok = validateCandidateNow();
break;
case OTNN_AUTONOMY_ACTION_SHADOW_CANDIDATE:
ok = shadowCandidateNow();
break;
case OTNN_AUTONOMY_ACTION_PROMOTE_CANDIDATE:
ok = promoteCandidateNow();
break;
case OTNN_AUTONOMY_ACTION_ROLLBACK_PREVIOUS:
ok = rollbackNow();
break;
case OTNN_AUTONOMY_ACTION_COMMIT_CATALOG:
ok = commitLifecycle("autonomy-dirty");
if(ok) g_controller.markCatalogCommitted();
break;
case OTNN_AUTONOMY_ACTION_REJECT_CANDIDATE:
ok = rejectCandidateNow();
break;
default:
ok = false;
break;
}
if(!g_controller.actionCompleted(action, ok)) ok = false;
if(ok && simplificationAction &&
(action == OTNN_AUTONOMY_ACTION_REJECT_CANDIDATE ||
action == OTNN_AUTONOMY_ACTION_ROLLBACK_PREVIOUS))
{
if(!g_controller.resumeActiveStable()) ok = false;
}
/* Gate evaluation must happen AFTER actionCompleted(VALIDATE/SHADOW),
* otherwise actionCompleted would overwrite the phase selected by the gates. */
if(ok && action == OTNN_AUTONOMY_ACTION_VALIDATE_CANDIDATE)
{
ok = g_controller.evaluatePromotionGates(g_activeSignature,
g_candidateSignature,
&g_dominanceReport,
0, g_gateReport);
if(ok)
{
logPrefix("GATES");
file.fprintf(g_logFile,
"stage=validation sample=%d float=%d q15=%d ready=%d latency=%d complexity=%d c[report=%d depth=%d width=%d params=%d macs=%d floatMem=%d trainMem=%d q15Mem=%d q15Normal=%d floatLatency=%d] dominance[applied=%d report=%d gate=%d] shadow=%d eligible=%d",
g_gateReport.sampleGate, g_gateReport.floatQualityGate,
g_gateReport.q15QualityGate, g_gateReport.q15ReadyGate,
g_gateReport.q15LatencyGate, g_gateReport.complexity.eligible,
g_gateReport.complexity.reportGate,
g_gateReport.complexity.hiddenLayersGate,
g_gateReport.complexity.hiddenWidthGate,
g_gateReport.complexity.parameterGate,
g_gateReport.complexity.macGate,
g_gateReport.complexity.floatRuntimeGate,
g_gateReport.complexity.trainingWorkspaceGate,
g_gateReport.complexity.q15RuntimeGate,
g_gateReport.complexity.q15NormalGate,
g_gateReport.complexity.floatLatencyGate,
g_gateReport.dominanceApplied,
g_gateReport.dominanceReportGate,
g_gateReport.dominanceGate,
g_gateReport.shadowGate, g_gateReport.eligible);
logEnd(1);
ok = updateDecisionTrace(0, "validation", 0);
}
}
else if(ok && action == OTNN_AUTONOMY_ACTION_SHADOW_CANDIDATE)
{
ok = g_controller.evaluatePromotionGates(g_activeSignature,
g_candidateSignature,
&g_dominanceReport,
&g_shadowReport, g_gateReport);
if(ok)
{
logPrefix("GATES");
file.fprintf(g_logFile,
"stage=shadow sample=%d float=%d q15=%d ready=%d latency=%d complexity=%d c[report=%d depth=%d width=%d params=%d macs=%d floatMem=%d trainMem=%d q15Mem=%d q15Normal=%d floatLatency=%d] dominance[applied=%d report=%d gate=%d] shadow=%d eligible=%d",
g_gateReport.sampleGate, g_gateReport.floatQualityGate,
g_gateReport.q15QualityGate, g_gateReport.q15ReadyGate,
g_gateReport.q15LatencyGate, g_gateReport.complexity.eligible,
g_gateReport.complexity.reportGate,
g_gateReport.complexity.hiddenLayersGate,
g_gateReport.complexity.hiddenWidthGate,
g_gateReport.complexity.parameterGate,
g_gateReport.complexity.macGate,
g_gateReport.complexity.floatRuntimeGate,
g_gateReport.complexity.trainingWorkspaceGate,
g_gateReport.complexity.q15RuntimeGate,
g_gateReport.complexity.q15NormalGate,
g_gateReport.complexity.floatLatencyGate,
g_gateReport.dominanceApplied,
g_gateReport.dominanceReportGate,
g_gateReport.dominanceGate,
g_gateReport.shadowGate, g_gateReport.eligible);
logEnd(1);
ok = updateDecisionTrace(&g_shadowReport, "shadow", 1);
}
}
if(!ok)
{
logPrefix("ERROR");
file.fprintf(g_logFile, "action=%s FAILED", otNeuralAutonomyController::actionName(action));
logEnd(1);
printf("FATAL: autonomous action %s failed.\n", otNeuralAutonomyController::actionName(action));
return false;
}
if(action == OTNN_AUTONOMY_ACTION_PROMOTE_CANDIDATE)
printSerialEvent("PROMOTION");
else if(action == OTNN_AUTONOMY_ACTION_ROLLBACK_PREVIOUS)
printSerialEvent("ROLLBACK");
else if(action == OTNN_AUTONOMY_ACTION_REJECT_CANDIDATE)
printSerialEvent("CANDIDATE REJECTED");
return true;
}
/* ------------------------------------------------------------------------- */
/* v0.23 Step 10 core self-test. Tiny locals only: 4 KiB-stack safe. */
/* ------------------------------------------------------------------------- */
static bool step6PromotionExplainabilitySelfTest(otNNValidationReport & validation,
otNNExecutionMetrics & execution,
const otNNComplexityReport & candidateComplexity,
otNNDominanceReport & dominance)
{
otNeuralAutonomyController controller;
otNNPromotionGateReport gates;
otNNShadowReport shadow;
static otNNComplexityReport activeComplexity;
static otNNMeaningfulImprovementReport improvement;
static otNNPromotionDecisionTrace trace;
/* Build a fully valid quality/Q15/shadow context so only the Step 5/6
dominance relation and its derived explanation change between checks. */
controller.init(0);
memset(&validation, 0, sizeof(validation));
validation.valid = 1;
validation.active.valid = 1;
validation.candidate.valid = 1;
validation.active.samples = 400UL;
validation.candidate.samples = 400UL;
validation.active.classificationAvailable = 1;
validation.candidate.classificationAvailable = 1;
validation.active.accuracyPercent = 90.0f;
validation.candidate.accuracyPercent = 90.5f;
validation.active.meanAbsError = 0.100f;
validation.candidate.meanAbsError = 0.095f;
validation.active.q15Prepared = 1;
validation.candidate.q15Prepared = 1;
validation.active.q15Evaluated = 1;
validation.candidate.q15Evaluated = 1;
validation.active.q15AccuracyPercent = 90.0f;
validation.candidate.q15AccuracyPercent = 90.5f;
validation.active.q15MeanAbsError = 0.100f;
validation.candidate.q15MeanAbsError = 0.095f;
memset(&execution, 0, sizeof(execution));
execution.q15LatencyValid = 1;
execution.q15LatencyUs = candidateComplexity.q15LatencyValid ?
candidateComplexity.q15LatencyUs : 7.5f;
memset(&shadow, 0, sizeof(shadow));
shadow.valid = 1;
shadow.activeExecutedFirst = 1;
shadow.candidateAuthority = 0;
shadow.samples = 400UL;
activeComplexity = candidateComplexity;
activeComplexity.valid = 1;
if(activeComplexity.parameters > 10UL) activeComplexity.parameters -= 10UL;
if(activeComplexity.macsPerInference > 10UL) activeComplexity.macsPerInference -= 10UL;
if(activeComplexity.floatRuntimeBytes > 40UL) activeComplexity.floatRuntimeBytes -= 40UL;
if(activeComplexity.trainingWorkspaceBytes > 20UL) activeComplexity.trainingWorkspaceBytes -= 20UL;
if(activeComplexity.q15RuntimeBytes > 20UL) activeComplexity.q15RuntimeBytes -= 20UL;
activeComplexity.q15LatencyValid = 1;
if(!activeComplexity.q15LatencyValid || activeComplexity.q15LatencyUs <= 0.0f)
activeComplexity.q15LatencyUs = 7.0f;
memset(&improvement, 0, sizeof(improvement));
improvement.valid = 1;
improvement.floatAccuracyAvailable = 1;
improvement.floatAccuracyGainPoints = 0.5f;
improvement.floatAccuracyMeaningful = 1;
improvement.floatMeanErrorAvailable = 1;
improvement.floatMeanErrorReductionRatio = 0.05f;
improvement.floatMeanErrorMeaningful = 1;
improvement.q15AccuracyAvailable = 1;
improvement.q15AccuracyGainPoints = 0.5f;
improvement.q15AccuracyMeaningful = 1;
improvement.q15MeanErrorAvailable = 1;
improvement.q15MeanErrorReductionRatio = 0.05f;
improvement.q15MeanErrorMeaningful = 1;
/* Candidate Pareto dominance passes and Step 6 explains why. */
memset(&dominance, 0, sizeof(dominance));
dominance.valid = 1;
dominance.candidateParetoDominates = 1;
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &dominance, &shadow, gates) ||
!gates.valid || !gates.dominanceApplied || !gates.dominanceReportGate ||
!gates.dominanceGate || !gates.eligible ||
!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, &shadow, trace) ||
!trace.valid || !trace.finalDecisionKnown || !trace.eligible ||
trace.reason != OTNN_DECISION_PROMOTE_PARETO ||
strcmp(controller.promotionDecisionReasonName(trace.reason), "PROMOTE_PARETO") != 0)
return false;
/* The same passed validation without shadow is explicitly pending, not reject. */
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &dominance, 0, gates) ||
!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, 0, trace) ||
trace.finalDecisionKnown || trace.eligible ||
trace.reason != OTNN_DECISION_WAIT_SHADOW)
return false;
/* ACTIVE dominance blocks and receives a stable reason code. */
memset(&dominance, 0, sizeof(dominance));
dominance.valid = 1;
dominance.activeParetoDominates = 1;
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &dominance, &shadow, gates) ||
gates.dominanceGate || gates.eligible ||
!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, &shadow, trace) ||
trace.reason != OTNN_DECISION_REJECT_ACTIVE_DOMINATES)
return false;
/* Meaningful bounded tradeoff passes. */
memset(&dominance, 0, sizeof(dominance));
dominance.valid = 1;
dominance.candidateBoundedTradeoff = 1;
dominance.meaningfulQualityGain = 1;
dominance.boundedExtraCost = 1;
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &dominance, &shadow, gates) ||
!gates.dominanceGate || !gates.eligible ||
!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, &shadow, trace) ||
trace.reason != OTNN_DECISION_PROMOTE_BOUNDED_TRADEOFF)
return false;
/* Equivalent and excessive relative-cost cases are differentiated. */
memset(&dominance, 0, sizeof(dominance));
dominance.valid = 1;
dominance.equivalent = 1;
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &dominance, &shadow, gates) ||
gates.dominanceGate || gates.eligible ||
!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, &shadow, trace) ||
trace.reason != OTNN_DECISION_REJECT_EQUIVALENT)
return false;
memset(&dominance, 0, sizeof(dominance));
dominance.valid = 1;
dominance.unresolvedTradeoff = 1;
dominance.meaningfulQualityGain = 1;
dominance.boundedExtraCost = 0;
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &dominance, &shadow, gates) ||
gates.dominanceGate || gates.eligible ||
!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, &shadow, trace) ||
trace.reason != OTNN_DECISION_REJECT_RELATIVE_COST)
return false;
/* Invalid supplied evidence blocks and is distinguishable from policy reject. */
memset(&dominance, 0, sizeof(dominance));
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &dominance, &shadow, gates) ||
gates.dominanceReportGate || gates.dominanceGate || gates.eligible ||
!controller.buildPromotionDecisionTrace(validation, activeComplexity,
candidateComplexity, improvement, dominance, gates, &shadow, trace) ||
trace.reason != OTNN_DECISION_REJECT_DOMINANCE_REPORT)
return false;
/* Historical overload remains source/behavior compatible. */
if(!controller.evaluatePromotionGates(validation, execution,
&candidateComplexity, &shadow, gates) ||
gates.dominanceApplied || !gates.dominanceGate || !gates.eligible)
return false;
return true;
}
static bool topologyStep11CoreSelfTest()
{
otNNTopology one;
otNNTopology multi;
otNNTopology deep;
otTinn model;
otTinn widenedModel;
otTinnWarmStartReport warmReport;
otTinnQ15MemoryInfo info;
otNNComplexityReport complexity;
otNNExecutionMetrics complexityExecution;
otNNModelDescriptor complexityDescriptor;
otNNComplexityGatePolicy complexityPolicy;
otNNComplexityGateReport complexityGates;
otNNMeaningfulImprovementPolicy improvementPolicy;
otNNMeaningfulImprovementReport improvementReport;
otNNValidationReport improvementValidation;
otNNDominancePolicy dominancePolicy;
otNNDominanceReport dominanceReport;
otNNComparisonReport dominanceComparison;
otNNComplexityReport activeDominanceComplexity;
otNNComplexityReport candidateDominanceComplexity;
float in[4];
float target[2];
float * out;
float f0, f1, q0, q1, d0, d1;
short qin[4];
short sourceRaw[2];
const short * raw;
int i;
in[0] = -0.75f;
in[1] = -0.10f;
in[2] = 0.35f;
in[3] = 0.90f;
target[0] = 1.0f;
target[1] = 0.0f;
otTinn::makeSingleHiddenTopology(one, 4, 2, 3);
if(!otTinn::supportsTopology(one) || !otTinn::supportsTrainingTopology(one) ||
!otTinn::supportsQ15Topology(one) ||
!otTinn::supportsLegacySerializationTopology(one) ||
!otTinn::supportsTrainingCheckpointTopology(one))
return false;
multi = one;
multi.hiddenLayers = 2;
multi.hidden[0] = 3;
multi.hidden[1] = 2;
if(!otTinn::supportsTopology(multi) || !otTinn::supportsTrainingTopology(multi) ||
!otTinn::supportsQ15Topology(multi) ||
!otTinn::supportsTrainingCheckpointTopology(multi) ||
otTinn::supportsLegacySerializationTopology(multi))
return false;
if(!model.init(multi, &file) || !model.valid())
return false;
for(i = 0; i < 64; ++i)
if(model.train(in, target, 0.20f) < 0.0f)
return false;
out = model.predict(in);
if(out == 0)
return false;
f0 = out[0];
f1 = out[1];
model.q15MemoryInfo(info);
if(info.totalBytes != 66UL || info.ready)
return false;
if(!model.prepareQ15() || !model.q15Ready())
return false;
model.q15MemoryInfo(info);
if(info.totalBytes != 66UL || !info.ready)
return false;
out = model.predictQ15(in);
if(out == 0)
return false;
q0 = out[0];
q1 = out[1];
d0 = f0 - q0; if(d0 < 0.0f) d0 = -d0;
d1 = f1 - q1; if(d1 < 0.0f) d1 = -d1;
if(d0 > 0.02f || d1 > 0.02f)
return false;
if(!model.quantizeInputQ15(in, qin))
return false;
raw = model.predictQ15Raw(qin);
if(raw == 0)
return false;
d0 = q0 - ((float)raw[0] / 32767.0f); if(d0 < 0.0f) d0 = -d0;
d1 = q1 - ((float)raw[1] / 32767.0f); if(d1 < 0.0f) d1 = -d1;
if(d0 > 0.000001f || d1 > 0.000001f)
return false;
/* Training must invalidate a stale Q15 copy, then allow reconstruction. */
if(model.train(in, target, 0.10f) < 0.0f || model.q15Ready())
return false;
if(!model.prepareQ15())
return false;
/* v0.24 Step 1: the complexity report is descriptive only. Verify exact
topology-derived quantities and transparent pass-through of measured latency. */
memset(&complexityExecution, 0, sizeof(complexityExecution));
complexityExecution.floatLatencyValid = 1;
complexityExecution.floatLatencyUs = 12.5f;
complexityExecution.q15LatencyValid = 1;
complexityExecution.q15LatencyUs = 7.5f;
otNeuralTrainingSession::makeDescriptor(complexityDescriptor, 1UL, 1UL, multi);
if(!otNeuralModelLifecycle::buildComplexityReport(
&model, complexityDescriptor, &complexityExecution, complexity) ||
!complexity.valid || complexity.hiddenLayers != 2 ||
complexity.maxHiddenWidth != 3 || complexity.hiddenNeurons != 5UL ||
complexity.parameters != 25UL || complexity.macsPerInference != 22UL ||
complexity.floatParameterBytes != 100UL ||
complexity.floatRuntimeBytes != 156UL ||
complexity.trainingWorkspaceBytes != 28UL ||
!complexity.q15Ready || complexity.q15RuntimeBytes != 66UL ||
!complexity.floatLatencyValid || complexity.floatLatencyUs != 12.5f ||
!complexity.q15LatencyValid || complexity.q15LatencyUs != 7.5f)
return false;
/* v0.24 Step 2: absolute complexity/resource gates remain independent.
They answer only "can this Candidate fit the configured target envelope?"
and deliberately make no ACTIVE-vs-CANDIDATE value judgement. */
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
!complexityGates.valid || !complexityGates.reportGate ||
!complexityGates.hiddenLayersGate || !complexityGates.hiddenWidthGate ||
!complexityGates.parameterGate || !complexityGates.macGate ||
!complexityGates.floatRuntimeGate || !complexityGates.trainingWorkspaceGate ||
!complexityGates.q15RuntimeGate || !complexityGates.q15NormalGate ||
!complexityGates.floatLatencyGate || !complexityGates.eligible)
return false;
/* Missing mandatory report is a single explicit gate failure, not an
invented failure of every resource dimension. */
if(!otNeuralAutonomyController::evaluateComplexityGates(
0, complexityPolicy, complexityGates) ||
complexityGates.reportGate || complexityGates.eligible ||
!complexityGates.parameterGate || !complexityGates.macGate)
return false;
/* Exercise independent hard-limit failures one by one. */
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.maximumHiddenLayers = 1;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.hiddenLayersGate || complexityGates.eligible)
return false;
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.maximumHiddenWidth = 2;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.hiddenWidthGate || complexityGates.eligible)
return false;
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.maximumParameters = 24UL;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.parameterGate || complexityGates.eligible)
return false;
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.maximumMacsPerInference = 21UL;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.macGate || complexityGates.eligible)
return false;
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.maximumFloatRuntimeBytes = 155UL;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.floatRuntimeGate || complexityGates.eligible)
return false;
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.maximumTrainingWorkspaceBytes = 27UL;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.trainingWorkspaceGate || complexityGates.eligible)
return false;
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.maximumQ15RuntimeBytes = 65UL;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.q15RuntimeGate || complexityGates.eligible)
return false;
otNeuralAutonomyController::defaultComplexityGatePolicy(complexityPolicy);
complexityPolicy.requireReport = 1;
complexityPolicy.requireFloatLatency = 1;
complexityPolicy.maximumFloatLatencyUs = 12.0f;
if(!otNeuralAutonomyController::evaluateComplexityGates(
&complexity, complexityPolicy, complexityGates) ||
complexityGates.floatLatencyGate || complexityGates.eligible)
return false;
/* v0.24 Step 3: meaningful quality improvement is evaluated per metric.
It is descriptive only here and is NOT wired into promotion eligibility. */
otNeuralModelLifecycle::defaultMeaningfulImprovementPolicy(improvementPolicy);
if(improvementPolicy.minimumFloatAccuracyGainPoints != 0.25f ||
improvementPolicy.minimumFloatMeanErrorReductionRatio != 0.02f ||
improvementPolicy.minimumQ15AccuracyGainPoints != 0.25f ||
improvementPolicy.minimumQ15MeanErrorReductionRatio != 0.02f)
return false;
memset(&improvementValidation, 0, sizeof(improvementValidation));
improvementValidation.valid = 1;
improvementValidation.active.valid = 1;
improvementValidation.candidate.valid = 1;
improvementValidation.active.samples = 400UL;
improvementValidation.candidate.samples = 400UL;
improvementValidation.active.classificationAvailable = 1;
improvementValidation.candidate.classificationAvailable = 1;
improvementValidation.active.accuracyPercent = 90.0f;
improvementValidation.candidate.accuracyPercent = 90.10f;
improvementValidation.active.meanAbsError = 0.100f;
improvementValidation.candidate.meanAbsError = 0.099f;
improvementValidation.active.q15Evaluated = 1;
improvementValidation.candidate.q15Evaluated = 1;
improvementValidation.active.q15AccuracyPercent = 89.0f;
improvementValidation.candidate.q15AccuracyPercent = 89.10f;
improvementValidation.active.q15MeanAbsError = 0.110f;
improvementValidation.candidate.q15MeanAbsError = 0.109f;
/* Small positive changes remain below the configured thresholds. */
if(!otNeuralModelLifecycle::evaluateMeaningfulImprovement(
improvementValidation, improvementPolicy, improvementReport) ||
!improvementReport.valid || !improvementReport.floatAccuracyAvailable ||
!improvementReport.floatMeanErrorAvailable ||
!improvementReport.q15AccuracyAvailable ||
!improvementReport.q15MeanErrorAvailable ||
improvementReport.floatAccuracyMeaningful ||
improvementReport.floatMeanErrorMeaningful ||
improvementReport.q15AccuracyMeaningful ||
improvementReport.q15MeanErrorMeaningful)
return false;
/* Each quality/error criterion can cross its threshold independently. */
improvementValidation.candidate.accuracyPercent = 90.50f;
improvementValidation.candidate.meanAbsError = 0.097f;
improvementValidation.candidate.q15AccuracyPercent = 89.50f;
improvementValidation.candidate.q15MeanAbsError = 0.106f;
if(!otNeuralModelLifecycle::evaluateMeaningfulImprovement(
improvementValidation, improvementPolicy, improvementReport) ||
!improvementReport.floatAccuracyMeaningful ||
!improvementReport.floatMeanErrorMeaningful ||
!improvementReport.q15AccuracyMeaningful ||
!improvementReport.q15MeanErrorMeaningful)
return false;
/* Regression is never a meaningful improvement. */
improvementValidation.candidate.accuracyPercent = 89.0f;
improvementValidation.candidate.meanAbsError = 0.110f;
improvementValidation.candidate.q15AccuracyPercent = 88.0f;
improvementValidation.candidate.q15MeanAbsError = 0.120f;
if(!otNeuralModelLifecycle::evaluateMeaningfulImprovement(
improvementValidation, improvementPolicy, improvementReport) ||
improvementReport.floatAccuracyMeaningful ||
improvementReport.floatMeanErrorMeaningful ||
improvementReport.q15AccuracyMeaningful ||
improvementReport.q15MeanErrorMeaningful)
return false;
/* v0.24 Step 4: dominance remains vector/logical, never scalar.
Exercise the four cases required by the v0.24 plan. */
otNeuralModelLifecycle::defaultDominancePolicy(dominancePolicy);
if(dominancePolicy.maximumParameterIncreaseRatio != 1.0f ||
dominancePolicy.maximumMacIncreaseRatio != 1.0f ||
dominancePolicy.maximumFloatRuntimeIncreaseRatio != 1.0f ||
dominancePolicy.maximumTrainingWorkspaceIncreaseRatio != 1.0f ||
dominancePolicy.maximumQ15RuntimeIncreaseRatio != 1.0f ||
dominancePolicy.maximumQ15LatencyIncreaseRatio != 1.0f)
return false;
memset(&dominanceComparison, 0, sizeof(dominanceComparison));
dominanceComparison.valid = 1;
dominanceComparison.floatAccuracy.available = 1;
dominanceComparison.floatAccuracy.relation = OTNN_COMPARE_CANDIDATE_BETTER;
dominanceComparison.floatMeanAbsError.available = 1;
dominanceComparison.floatMeanAbsError.relation = OTNN_COMPARE_EQUAL;
dominanceComparison.q15Accuracy.available = 1;
dominanceComparison.q15Accuracy.relation = OTNN_COMPARE_EQUAL;
dominanceComparison.q15MeanAbsError.available = 1;
dominanceComparison.q15MeanAbsError.relation = OTNN_COMPARE_EQUAL;
memset(&improvementReport, 0, sizeof(improvementReport));
improvementReport.valid = 1;
memset(&activeDominanceComplexity, 0, sizeof(activeDominanceComplexity));
activeDominanceComplexity.valid = 1;
activeDominanceComplexity.parameters = 1000UL;
activeDominanceComplexity.macsPerInference = 900UL;
activeDominanceComplexity.floatRuntimeBytes = 5000UL;
activeDominanceComplexity.trainingWorkspaceBytes = 1000UL;
activeDominanceComplexity.q15Ready = 1;
activeDominanceComplexity.q15RuntimeBytes = 2500UL;
activeDominanceComplexity.q15LatencyValid = 1;
activeDominanceComplexity.q15LatencyUs = 100.0f;
candidateDominanceComplexity = activeDominanceComplexity;
candidateDominanceComplexity.parameters = 3000UL;
candidateDominanceComplexity.macsPerInference = 2700UL;
candidateDominanceComplexity.floatRuntimeBytes = 15000UL;
candidateDominanceComplexity.trainingWorkspaceBytes = 3000UL;
candidateDominanceComplexity.q15RuntimeBytes = 7500UL;
candidateDominanceComplexity.q15LatencyUs = 300.0f;
/* Slightly better but ~3x larger: unresolved, not justified. */
if(!otNeuralModelLifecycle::evaluateDominance(
dominanceComparison, improvementReport, activeDominanceComplexity,
candidateDominanceComplexity, dominancePolicy, dominanceReport) ||
!dominanceReport.valid || dominanceReport.candidateParetoDominates ||
dominanceReport.activeParetoDominates ||
dominanceReport.candidateBoundedTradeoff ||
!dominanceReport.unresolvedTradeoff || dominanceReport.boundedExtraCost)
return false;
/* Meaningfully better with +50% bounded cost: explicit bounded trade-off. */
improvementReport.floatAccuracyMeaningful = 1;
candidateDominanceComplexity.parameters = 1500UL;
candidateDominanceComplexity.macsPerInference = 1350UL;
candidateDominanceComplexity.floatRuntimeBytes = 7500UL;
candidateDominanceComplexity.trainingWorkspaceBytes = 1500UL;
candidateDominanceComplexity.q15RuntimeBytes = 3750UL;
candidateDominanceComplexity.q15LatencyUs = 150.0f;
if(!otNeuralModelLifecycle::evaluateDominance(
dominanceComparison, improvementReport, activeDominanceComplexity,
candidateDominanceComplexity, dominancePolicy, dominanceReport) ||
!dominanceReport.candidateBoundedTradeoff ||
dominanceReport.candidateParetoDominates ||
dominanceReport.activeParetoDominates ||
!dominanceReport.boundedExtraCost)
return false;
/* Larger with equal quality: ACTIVE Pareto-dominates. */
dominanceComparison.floatAccuracy.relation = OTNN_COMPARE_EQUAL;
improvementReport.floatAccuracyMeaningful = 0;
if(!otNeuralModelLifecycle::evaluateDominance(
dominanceComparison, improvementReport, activeDominanceComplexity,
candidateDominanceComplexity, dominancePolicy, dominanceReport) ||
!dominanceReport.activeParetoDominates ||
dominanceReport.candidateParetoDominates ||
dominanceReport.candidateBoundedTradeoff)
return false;
/* Smaller with equal quality: Candidate Pareto-dominates. */
candidateDominanceComplexity.parameters = 800UL;
candidateDominanceComplexity.macsPerInference = 720UL;
candidateDominanceComplexity.floatRuntimeBytes = 4000UL;
candidateDominanceComplexity.trainingWorkspaceBytes = 800UL;
candidateDominanceComplexity.q15RuntimeBytes = 2000UL;
candidateDominanceComplexity.q15LatencyUs = 80.0f;
if(!otNeuralModelLifecycle::evaluateDominance(
dominanceComparison, improvementReport, activeDominanceComplexity,
candidateDominanceComplexity, dominancePolicy, dominanceReport) ||
!dominanceReport.candidateParetoDominates ||
dominanceReport.activeParetoDominates ||
dominanceReport.candidateBoundedTradeoff)
return false;
/* v0.24 Step 5: Step 4 evidence is now an independent promotion gate. */
if(!step6PromotionExplainabilitySelfTest(improvementValidation, complexityExecution,
candidateDominanceComplexity, dominanceReport))
return false;
model.close();
deep = one;
deep.hiddenLayers = 4;
deep.hidden[0] = 4;
deep.hidden[1] = 3;
deep.hidden[2] = 3;
deep.hidden[3] = 2;
if(!otTinn::supportsQ15Topology(deep) || !model.init(deep, &file))
return false;
model.q15MemoryInfo(info);
if(info.totalBytes != 130UL)
return false;
if(!model.prepareQ15() || model.predictQ15(in) == 0)
return false;
model.close();
/* Step 9: preserve the current function when retrying or widening at equal
depth. Width expansion must preserve both float and raw Q15 outputs before
any new training sample is applied. Depth changes deliberately stay fresh. */
if(!model.init(one, &file))
return false;
out = model.predict(in);
if(out == 0) return false;
f0 = out[0]; f1 = out[1];
if(!model.prepareQ15() || !model.quantizeInputQ15(in, qin)) return false;
raw = model.predictQ15Raw(qin);
if(raw == 0) return false;
sourceRaw[0] = raw[0]; sourceRaw[1] = raw[1];
multi = one;
multi.hidden[0] = 5;
if(!widenedModel.init(multi, &file)) return false;
if(!widenedModel.warmStartFrom(model, warmReport) ||
warmReport.mode != OTNN_WARMSTART_FUNCTION_PRESERVING_WIDEN ||
!warmReport.functionPreserved || warmReport.copiedWeights != 18UL ||
warmReport.zeroedWeights != 4UL || warmReport.retainedRandomWeights != 8UL)
return false;
out = widenedModel.predict(in);
if(out == 0 || out[0] != f0 || out[1] != f1) return false;
if(!widenedModel.prepareQ15() || !widenedModel.quantizeInputQ15(in, qin)) return false;
raw = widenedModel.predictQ15Raw(qin);
if(raw == 0 || raw[0] != sourceRaw[0] || raw[1] != sourceRaw[1]) return false;
widenedModel.close();
if(!widenedModel.init(one, &file) ||
!widenedModel.warmStartFrom(model, warmReport) ||
warmReport.mode != OTNN_WARMSTART_EXACT_CLONE || !warmReport.functionPreserved)
return false;
out = widenedModel.predict(in);
if(out == 0 || out[0] != f0 || out[1] != f1) return false;
/* v0.25 Step 2: same-depth narrowing uses deterministic structured
PRUNE-COPY. It preserves selected trained structure but deliberately
does not claim exact function preservation. Repeating the transform
must be bit-deterministic regardless of the destination random init. */
multi = one;
multi.hidden[0] = 2;
widenedModel.close();
if(!widenedModel.init(multi, &file) ||
!widenedModel.warmStartFrom(model, warmReport) ||
warmReport.mode != OTNN_WARMSTART_STRUCTURED_PRUNE_COPY ||
warmReport.functionPreserved || warmReport.copiedWeights != 12UL ||
warmReport.selectedNeurons != 2UL || warmReport.prunedNeurons != 1UL)
return false;
out = widenedModel.predict(in);
if(out == 0) return false;
q0 = out[0]; q1 = out[1];
if(!widenedModel.prepareQ15() || widenedModel.predictQ15(in) == 0) return false;
widenedModel.close();
if(!widenedModel.init(multi, &file) ||
!widenedModel.warmStartFrom(model, warmReport)) return false;
out = widenedModel.predict(in);
if(out == 0 || out[0] != q0 || out[1] != q1) return false;
deep = one;
deep.hiddenLayers = 2;
deep.hidden[0] = 3;
deep.hidden[1] = 2;
widenedModel.close();
if(!widenedModel.init(deep, &file)) return false;
if(widenedModel.warmStartFrom(model, warmReport)) return false;
widenedModel.close();
model.close();
/* Step 6: deterministic bounded architecture escalation. */
{
otNNTopology active;
otNNArchitecturePolicy policy;
otNNArchitecturePlan plan;
otTinn::makeSingleHiddenTopology(active, 256, 10, 28);
otNeuralAutonomyController::defaultArchitecturePolicy(policy);
if(!otNeuralAutonomyController::planCandidateTopology(active, 0UL, policy, plan) ||
plan.changed || plan.topology.hiddenLayers != 1 || plan.topology.hidden[0] != 28) return false;
if(!otNeuralAutonomyController::planCandidateTopology(active, 1UL, policy, plan) ||
plan.changed || plan.topology.hidden[0] != 28) return false;
if(!otNeuralAutonomyController::planCandidateTopology(active, 2UL, policy, plan) ||
!plan.changed || plan.topology.hiddenLayers != 1 || plan.topology.hidden[0] != 48) return false;
if(!otNeuralAutonomyController::planCandidateTopology(active, 3UL, policy, plan) ||
plan.topology.hiddenLayers != 1 || plan.topology.hidden[0] != 56) return false;
if(!otNeuralAutonomyController::planCandidateTopology(active, 4UL, policy, plan) ||
plan.topology.hiddenLayers != 2 || plan.topology.hidden[0] != 48 ||
plan.topology.hidden[1] != 24 || plan.parameters != 13683UL) return false;
if(!otNeuralAutonomyController::planCandidateTopology(active, 6UL, policy, plan) ||
plan.topology.hiddenLayers != 3 || plan.topology.hidden[0] != 48 ||
plan.topology.hidden[1] != 24 || plan.topology.hidden[2] != 16) return false;
if(!otNeuralAutonomyController::planCandidateTopology(active, 8UL, policy, plan) ||
plan.topology.hiddenLayers != 4 || plan.topology.hidden[0] != 48 ||
plan.topology.hidden[1] != 24 || plan.topology.hidden[2] != 16 ||
plan.topology.hidden[3] != 8) return false;
if(!otNeuralAutonomyController::planCandidateTopology(active, 99UL, policy, plan) ||
plan.stage != 9 || plan.topology.hiddenLayers != 4 ||
plan.topology.hidden[0] != 56 || plan.topology.hidden[1] != 32 ||
plan.topology.hidden[2] != 16 || plan.topology.hidden[3] != 8) return false;
policy.maximumParameters = 10000UL;
if(!otNeuralAutonomyController::planCandidateTopology(active, 4UL, policy, plan) ||
!plan.resourceLimited || plan.changed || plan.topology.hidden[0] != 28) return false;
otNeuralAutonomyController::defaultArchitecturePolicy(policy);
if(!otNeuralAutonomyController::planCandidateTopologyWithHistory(
active, 2UL, 2UL, 0UL, (1UL << 2) | (1UL << 3), policy, plan) ||
plan.stage != 4 || !plan.historyLimited || plan.historySkippedStages != 2 ||
plan.topology.hiddenLayers != 2 || plan.topology.hidden[0] != 48 ||
plan.topology.hidden[1] != 24 || plan.parameters != 13683UL) return false;
}
/* v0.25 Step 1: use SDRAM-resident test objects; no new stack pressure. */
otNeuralAutonomyController::defaultSimplificationPolicy(g_v025SimplificationPolicy);
otTinn::makeSingleHiddenTopology(g_v025SimplificationActive, 256, 10, 28);
if(!otNeuralAutonomyController::planSimplerTopology(
g_v025SimplificationActive, 0UL, g_v025SimplificationPolicy,
g_v025SimplificationPlan) ||
!g_v025SimplificationPlan.valid || !g_v025SimplificationPlan.changed ||
g_v025SimplificationPlan.saturated ||
g_v025SimplificationPlan.lastAction != OTNN_SIMPLIFY_NARROW_HIDDEN ||
g_v025SimplificationPlan.topology.hidden[0] != 24 ||
g_v025SimplificationPlan.parameters != 6386UL) return false;
if(!otNeuralAutonomyController::planSimplerTopology(
g_v025SimplificationActive, 2UL, g_v025SimplificationPolicy,
g_v025SimplificationPlan) ||
!g_v025SimplificationPlan.saturated ||
g_v025SimplificationPlan.topology.hiddenLayers != 1 ||
g_v025SimplificationPlan.topology.hidden[0] != 8 ||
g_v025SimplificationPlan.parameters != 2130UL) return false;
memset(&g_v025SimplificationActive, 0, sizeof(g_v025SimplificationActive));
g_v025SimplificationActive.inputs = 256;
g_v025SimplificationActive.outputs = 10;
g_v025SimplificationActive.hiddenLayers = 4;
g_v025SimplificationActive.hidden[0] = 48;
g_v025SimplificationActive.hidden[1] = 24;
g_v025SimplificationActive.hidden[2] = 16;
g_v025SimplificationActive.hidden[3] = 8;
if(!otNeuralAutonomyController::planSimplerTopology(
g_v025SimplificationActive, 0UL, g_v025SimplificationPolicy,
g_v025SimplificationPlan) ||
g_v025SimplificationPlan.topology.hidden[2] != 8 ||
g_v025SimplificationPlan.parameters != 13781UL) return false;
if(!otNeuralAutonomyController::planSimplerTopology(
g_v025SimplificationActive, 8UL, g_v025SimplificationPolicy,
g_v025SimplificationPlan) ||
g_v025SimplificationPlan.lastAction != OTNN_SIMPLIFY_REMOVE_DEEPEST ||
g_v025SimplificationPlan.topology.hiddenLayers != 3 ||
g_v025SimplificationPlan.parameters != 2260UL) return false;
if(!otNeuralAutonomyController::planSimplerTopology(
g_v025SimplificationActive, 10UL, g_v025SimplificationPolicy,
g_v025SimplificationPlan) ||
!g_v025SimplificationPlan.saturated ||
g_v025SimplificationPlan.topology.hiddenLayers != 1 ||
g_v025SimplificationPlan.topology.hidden[0] != 8 ||
g_v025SimplificationPlan.parameters != 2130UL) return false;
return true;
}
/* ------------------------------------------------------------------------- */
/* v0.24 Step 7 deterministic end-to-end decision-path regression. */
/* */
/* This is deliberately stronger than a flag/unit test: each case binds real */
/* ACTIVE/CANDIDATE otTinn objects to the lifecycle, derives Step 1..4 */
/* evidence, lets Step 5 gates choose the controller action, verifies Step 6 */
/* reason logging, then executes the real lifecycle PROMOTE or REJECT role */
/* transaction. Tiny networks keep the boot regression cheap and 4 KiB-safe. */
/* ------------------------------------------------------------------------- */
FAST_CODE_2 static bool step7RunDecisionScenario(int scenario,
int expectedReason,
int expectPromotion,
otFILE * fs,
const char * label)
{
bool ok = false;
int action;
unsigned long activeId;
unsigned long candidateId;
float candidateAccuracy;
float candidateError;
float candidateQ15Latency;
g_step7Lifecycle.reset();
g_step7ActiveModel.close();
g_step7CandidateModel.close();
memset(&g_step7ActiveTopology, 0, sizeof(g_step7ActiveTopology));
memset(&g_step7CandidateTopology, 0, sizeof(g_step7CandidateTopology));
g_step7ActiveTopology.inputs = g_step7CandidateTopology.inputs = 4;
g_step7ActiveTopology.outputs = g_step7CandidateTopology.outputs = 2;
g_step7ActiveTopology.hiddenLayers = g_step7CandidateTopology.hiddenLayers = 1;
/* Four deterministic cases from the v0.24 plan. */
switch(scenario)
{
case 1: /* meaningful but far too expensive -> reject relative cost */
g_step7ActiveTopology.hidden[0] = 4;
g_step7CandidateTopology.hidden[0] = 16;
candidateAccuracy = 90.30f;
candidateError = 0.097f;
candidateQ15Latency = 30.0f;
break;
case 2: /* clearly better, moderately larger -> bounded tradeoff promote */
g_step7ActiveTopology.hidden[0] = 4;
g_step7CandidateTopology.hidden[0] = 6;
candidateAccuracy = 91.00f;
candidateError = 0.090f;
candidateQ15Latency = 15.0f;
break;
case 3: /* larger with no quality gain -> ACTIVE dominates */
g_step7ActiveTopology.hidden[0] = 4;
g_step7CandidateTopology.hidden[0] = 6;
candidateAccuracy = 90.00f;
candidateError = 0.100f;
candidateQ15Latency = 15.0f;
break;
case 4: /* simpler at equal quality -> Candidate Pareto dominates */
g_step7ActiveTopology.hidden[0] = 6;
g_step7CandidateTopology.hidden[0] = 4;
candidateAccuracy = 90.00f;
candidateError = 0.100f;
candidateQ15Latency = 8.0f;
break;
default:
goto cleanup;
}
activeId = 9700UL + (unsigned long)scenario * 2UL;
candidateId = activeId + 1UL;
if(!g_step7ActiveModel.init(g_step7ActiveTopology, fs)) goto cleanup;
otNeuralTrainingSession::makeDescriptor(g_step7ActiveD, activeId, 1UL, g_step7ActiveTopology);
if(!g_step7Lifecycle.attachActive(&g_step7ActiveModel, g_step7ActiveD)) goto cleanup;
otNeuralTrainingSession::makeDescriptor(g_step7CandidateD, candidateId, 1UL, g_step7CandidateTopology);
if(!g_step7Lifecycle.prepareCandidate(&g_step7CandidateModel, g_step7CandidateD, fs)) goto cleanup;
/* Tiny Q15 runtimes make the evidence structurally realistic while keeping
the regression negligible compared with the production networks. */
if(!g_step7ActiveModel.prepareQ15() || !g_step7CandidateModel.prepareQ15()) goto cleanup;
memset(&g_step7ActiveExecution, 0, sizeof(g_step7ActiveExecution));
memset(&g_step7CandidateExecution, 0, sizeof(g_step7CandidateExecution));
g_step7ActiveExecution.q15LatencyValid = 1;
g_step7ActiveExecution.q15LatencyUs = 10.0f;
g_step7CandidateExecution.q15LatencyValid = 1;
g_step7CandidateExecution.q15LatencyUs = candidateQ15Latency;
if(!otNeuralModelLifecycle::buildComplexityReport(&g_step7ActiveModel, g_step7ActiveD,
&g_step7ActiveExecution, g_step7ActiveComplexity) ||
!otNeuralModelLifecycle::buildComplexityReport(&g_step7CandidateModel, g_step7CandidateD,
&g_step7CandidateExecution, g_step7CandidateComplexity)) goto cleanup;
g_step7ActiveModel.q15MemoryInfo(g_step7ActiveQ15);
g_step7CandidateModel.q15MemoryInfo(g_step7CandidateQ15);
memset(&g_step7Validation, 0, sizeof(g_step7Validation));
g_step7Validation.valid = 1;
g_step7Validation.firstRow = 0;
g_step7Validation.sampleCount = 400;
g_step7Validation.active.valid = g_step7Validation.candidate.valid = 1;
g_step7Validation.active.samples = g_step7Validation.candidate.samples = 400UL;
g_step7Validation.active.classificationAvailable = g_step7Validation.candidate.classificationAvailable = 1;
g_step7Validation.active.accuracyPercent = 90.0f;
g_step7Validation.candidate.accuracyPercent = candidateAccuracy;
g_step7Validation.active.meanAbsError = 0.100f;
g_step7Validation.candidate.meanAbsError = candidateError;
g_step7Validation.active.parameterCount = g_step7ActiveComplexity.parameters;
g_step7Validation.candidate.parameterCount = g_step7CandidateComplexity.parameters;
g_step7Validation.active.q15Prepared = g_step7Validation.candidate.q15Prepared = 1;
g_step7Validation.active.q15Evaluated = g_step7Validation.candidate.q15Evaluated = 1;
g_step7Validation.active.q15AccuracyPercent = 90.0f;
g_step7Validation.candidate.q15AccuracyPercent = candidateAccuracy;
g_step7Validation.active.q15MeanAbsError = 0.100f;
g_step7Validation.candidate.q15MeanAbsError = candidateError;
g_step7Validation.active.q15Memory = g_step7ActiveQ15;
g_step7Validation.candidate.q15Memory = g_step7CandidateQ15;
otNeuralModelLifecycle::defaultComparisonPolicy(g_step7ComparisonPolicy);
otNeuralModelLifecycle::defaultMeaningfulImprovementPolicy(g_step7ImprovementPolicy);
otNeuralModelLifecycle::defaultDominancePolicy(g_step7DominancePolicy);
if(!otNeuralModelLifecycle::evaluateMeaningfulImprovement(
g_step7Validation, g_step7ImprovementPolicy, g_step7Improvement)) goto cleanup;
if(!g_step7Lifecycle.compareCandidate(g_step7Validation, g_step7ActiveExecution, g_step7CandidateExecution,
g_step7ComparisonPolicy, g_step7Comparison)) goto cleanup;
if(!otNeuralModelLifecycle::evaluateDominance(g_step7Comparison, g_step7Improvement,
g_step7ActiveComplexity, g_step7CandidateComplexity, g_step7DominancePolicy, g_step7Dominance)) goto cleanup;
g_step7Controller.init(0);
otNeuralAutonomyController::defaultComplexityGatePolicy(g_step7ComplexityPolicy);
g_step7ComplexityPolicy.requireReport = 1;
g_step7Controller.setComplexityGatePolicy(&g_step7ComplexityPolicy);
g_step7Controller.setOperatingWindow(OTNN_WINDOW_MAINTENANCE);
g_step7Controller.observeMonitorState(OTNN_MONITOR_RETRAIN_REQUIRED);
action = g_step7Controller.nextAction(g_step7Lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_VALIDATE_CANDIDATE ||
!g_step7Controller.actionCompleted(action, true)) goto cleanup;
if(!g_step7Controller.evaluatePromotionGates(g_step7Validation, g_step7CandidateExecution,
&g_step7CandidateComplexity, &g_step7Dominance, 0, g_step7Gates)) goto cleanup;
if(!g_step7Controller.buildPromotionDecisionTrace(g_step7Validation, g_step7ActiveComplexity,
g_step7CandidateComplexity, g_step7Improvement, g_step7Dominance, g_step7Gates, 0, g_step7Trace)) goto cleanup;
if(expectPromotion)
{
if(g_step7Trace.reason != OTNN_DECISION_WAIT_SHADOW || g_step7Trace.finalDecisionKnown)
goto cleanup;
action = g_step7Controller.nextAction(g_step7Lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_SHADOW_CANDIDATE ||
!g_step7Controller.actionCompleted(action, true)) goto cleanup;
memset(&g_step7Shadow, 0, sizeof(g_step7Shadow));
g_step7Shadow.valid = 1;
g_step7Shadow.activeExecutedFirst = 1;
g_step7Shadow.candidateAuthority = 0;
g_step7Shadow.samples = 400UL;
if(!g_step7Controller.evaluatePromotionGates(g_step7Validation, g_step7CandidateExecution,
&g_step7CandidateComplexity, &g_step7Dominance, &g_step7Shadow, g_step7Gates)) goto cleanup;
if(!g_step7Controller.buildPromotionDecisionTrace(g_step7Validation, g_step7ActiveComplexity,
g_step7CandidateComplexity, g_step7Improvement, g_step7Dominance, g_step7Gates, &g_step7Shadow, g_step7Trace)) goto cleanup;
if(!g_step7Trace.finalDecisionKnown || !g_step7Trace.eligible || g_step7Trace.reason != expectedReason)
goto cleanup;
action = g_step7Controller.nextAction(g_step7Lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_PROMOTE_CANDIDATE) goto cleanup;
memset(&g_step7Promotion, 0, sizeof(g_step7Promotion));
if(!g_step7Lifecycle.promoteCandidate(g_step7Promotion) ||
!g_step7Controller.actionCompleted(action, true)) goto cleanup;
if(!g_step7Lifecycle.activeDescriptor(g_step7AfterD) || g_step7AfterD.modelId != candidateId ||
!g_step7Lifecycle.hasPrevious() || g_step7Lifecycle.hasCandidate() ||
g_step7Controller.phase() != OTNN_AUTONOMY_PROBATION) goto cleanup;
}
else
{
if(!g_step7Trace.finalDecisionKnown || g_step7Trace.eligible || g_step7Trace.reason != expectedReason)
goto cleanup;
action = g_step7Controller.nextAction(g_step7Lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_REJECT_CANDIDATE) goto cleanup;
g_step7Lifecycle.clearCandidate();
if(!g_step7Controller.actionCompleted(action, true)) goto cleanup;
if(!g_step7Lifecycle.activeDescriptor(g_step7AfterD) || g_step7AfterD.modelId != activeId ||
g_step7Lifecycle.hasCandidate() || g_step7Lifecycle.hasPrevious() ||
g_step7Controller.phase() != OTNN_AUTONOMY_RETRAIN_PENDING) goto cleanup;
if(g_step7Controller.nextAction(g_step7Lifecycle, OTNN_TRAINING_PAUSED) !=
OTNN_AUTONOMY_ACTION_CREATE_CANDIDATE) goto cleanup;
}
printf(" Step 7 case %d %-28s : %s -> %s PASS\n",
scenario, label,
otNeuralAutonomyController::promotionDecisionReasonName(g_step7Trace.reason),
expectPromotion ? "PROMOTE" : "REJECT");
ok = true;
cleanup:
g_step7Lifecycle.reset();
g_step7ActiveModel.close();
g_step7CandidateModel.close();
return ok;
}
FAST_CODE_2 static bool step7DeterministicDecisionPathSelfTest(otFILE * fs)
{
printf("v0.25 SIGNATURE2 deterministic policy-equivalence validation: START\n");
if(!step7RunDecisionScenario(1, OTNN_DECISION_REJECT_RELATIVE_COST, 0, fs,
"better / >2x cost")) return false;
if(!step7RunDecisionScenario(2, OTNN_DECISION_PROMOTE_BOUNDED_TRADEOFF, 1, fs,
"better / bounded cost")) return false;
if(!step7RunDecisionScenario(3, OTNN_DECISION_REJECT_ACTIVE_DOMINATES, 0, fs,
"larger / no gain")) return false;
if(!step7RunDecisionScenario(4, OTNN_DECISION_PROMOTE_PARETO, 1, fs,
"smaller / equal quality")) return false;
printf("v0.25 SIGNATURE2 deterministic policy-equivalence validation: PASS\n");
return true;
}
FAST_CODE_2 static bool step3SimplificationTriggerSelfTest()
{
otNeuralAutonomyController::defaultSimplificationPolicy(g_v025SimplificationPolicy);
otTinn::makeSingleHiddenTopology(g_v025SimplificationActive, 256, 10, 28);
if(!otNeuralAutonomyController::planSimplerTopology(
g_v025SimplificationActive, 0UL, g_v025SimplificationPolicy,
g_v025SimplificationPlan) ||
!g_v025SimplificationPlan.valid || !g_v025SimplificationPlan.changed)
return false;
otNeuralAutonomyController::defaultSimplificationTriggerPolicy(g_v025TriggerPolicy);
memset(&g_v025TriggerContext, 0, sizeof(g_v025TriggerContext));
g_v025TriggerContext.autonomyPhase = OTNN_AUTONOMY_ACTIVE_STABLE;
g_v025TriggerContext.monitorState = OTNN_MONITOR_GOOD;
g_v025TriggerContext.stableSamples = g_v025TriggerPolicy.minimumStableSamples;
g_v025TriggerContext.activeAgeSamples = g_v025TriggerPolicy.minimumActiveAgeSamples;
g_v025TriggerContext.previousAttemptKnown = 0;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
g_v025SimplificationPlan, g_v025TriggerContext,
g_v025TriggerPolicy, g_v025TriggerReport) ||
!g_v025TriggerReport.valid || !g_v025TriggerReport.eligible ||
g_v025TriggerReport.reason != OTNN_SIMPLIFY_TRIGGER_ELIGIBLE ||
g_v025TriggerReport.parameterReductionRatio < 0.05f)
return false;
g_v025TriggerContext.stableSamples = g_v025TriggerPolicy.minimumStableSamples - 1UL;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
g_v025SimplificationPlan, g_v025TriggerContext,
g_v025TriggerPolicy, g_v025TriggerReport) ||
g_v025TriggerReport.eligible ||
g_v025TriggerReport.reason != OTNN_SIMPLIFY_TRIGGER_STABILITY_DWELL)
return false;
g_v025TriggerContext.stableSamples = g_v025TriggerPolicy.minimumStableSamples;
g_v025TriggerContext.activeAgeSamples = g_v025TriggerPolicy.minimumActiveAgeSamples - 1UL;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
g_v025SimplificationPlan, g_v025TriggerContext,
g_v025TriggerPolicy, g_v025TriggerReport) ||
g_v025TriggerReport.eligible ||
g_v025TriggerReport.reason != OTNN_SIMPLIFY_TRIGGER_ACTIVE_AGE_HOLDOFF)
return false;
g_v025TriggerContext.activeAgeSamples = g_v025TriggerPolicy.minimumActiveAgeSamples;
g_v025TriggerContext.previousAttemptKnown = 1;
g_v025TriggerContext.samplesSincePreviousAttempt = g_v025TriggerPolicy.cooldownSamples - 1UL;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
g_v025SimplificationPlan, g_v025TriggerContext,
g_v025TriggerPolicy, g_v025TriggerReport) ||
g_v025TriggerReport.eligible ||
g_v025TriggerReport.reason != OTNN_SIMPLIFY_TRIGGER_COOLDOWN)
return false;
g_v025TriggerContext.samplesSincePreviousAttempt = g_v025TriggerPolicy.cooldownSamples;
g_v025TriggerContext.monitorState = OTNN_MONITOR_WARNING;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
g_v025SimplificationPlan, g_v025TriggerContext,
g_v025TriggerPolicy, g_v025TriggerReport) ||
g_v025TriggerReport.eligible ||
g_v025TriggerReport.reason != OTNN_SIMPLIFY_TRIGGER_MONITOR_UNSTABLE)
return false;
g_v025TriggerContext.monitorState = OTNN_MONITOR_NOTICE;
g_v025TriggerContext.hasPrevious = 1;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
g_v025SimplificationPlan, g_v025TriggerContext,
g_v025TriggerPolicy, g_v025TriggerReport) ||
g_v025TriggerReport.eligible ||
g_v025TriggerReport.reason != OTNN_SIMPLIFY_TRIGGER_ROLE_BUSY)
return false;
g_v025TriggerContext.hasPrevious = 0;
g_v025TriggerContext.autonomyPhase = OTNN_AUTONOMY_RETRAIN_PENDING;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
g_v025SimplificationPlan, g_v025TriggerContext,
g_v025TriggerPolicy, g_v025TriggerReport) ||
g_v025TriggerReport.eligible ||
g_v025TriggerReport.reason != OTNN_SIMPLIFY_TRIGGER_PHASE_BUSY)
return false;
g_v025TriggerContext.autonomyPhase = OTNN_AUTONOMY_ACTIVE_STABLE;
g_v025TriggerPolicy.minimumParameterReductionRatio = 0.50f;
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
g_v025SimplificationPlan, g_v025TriggerContext,
g_v025TriggerPolicy, g_v025TriggerReport) ||
g_v025TriggerReport.eligible ||
g_v025TriggerReport.reason != OTNN_SIMPLIFY_TRIGGER_SAVINGS_TOO_SMALL)
return false;
return true;
}
FAST_CODE_2 static bool step4SimplificationLifecycleSelfTest(otFILE * fs)
{
otTinnWarmStartReport warm;
g_step7Lifecycle.reset();
g_step7ActiveModel.close();
g_step7CandidateModel.close();
g_step7Controller.init(0);
otNeuralAutonomyController::defaultSimplificationPolicy(g_v025SimplificationPolicy);
otTinn::makeSingleHiddenTopology(g_step7ActiveTopology, 8, 2, 12);
if(!otNeuralAutonomyController::planSimplerTopology(
g_step7ActiveTopology, 0UL, g_v025SimplificationPolicy,
g_v025SimplificationPlan) ||
!g_v025SimplificationPlan.valid || !g_v025SimplificationPlan.changed ||
g_v025SimplificationPlan.topology.hidden[0] != 8)
goto fail;
if(!g_step7ActiveModel.init(g_step7ActiveTopology, fs)) goto fail;
otNeuralTrainingSession::makeDescriptor(g_step7ActiveD, 25101UL, 1UL, g_step7ActiveTopology);
if(!g_step7Lifecycle.attachActive(&g_step7ActiveModel, g_step7ActiveD)) goto fail;
otNeuralTrainingSession::makeDescriptor(g_step7CandidateD, 25102UL, 1UL,
g_v025SimplificationPlan.topology);
if(!g_step7Lifecycle.prepareCandidate(&g_step7CandidateModel, g_step7CandidateD, fs)) goto fail;
memset(&warm, 0, sizeof(warm));
if(!g_step7CandidateModel.warmStartFrom(g_step7ActiveModel, warm) ||
warm.mode != OTNN_WARMSTART_STRUCTURED_PRUNE_COPY || warm.functionPreserved)
goto fail;
if(!g_step7Controller.resumeTraining() ||
g_step7Controller.phase() != OTNN_AUTONOMY_TRAINING) goto fail;
g_step7Lifecycle.clearCandidate();
g_step7CandidateModel.close();
if(!g_step7Controller.actionCompleted(OTNN_AUTONOMY_ACTION_REJECT_CANDIDATE, true) ||
g_step7Controller.phase() != OTNN_AUTONOMY_RETRAIN_PENDING) goto fail;
if(!g_step7Controller.resumeActiveStable() ||
g_step7Controller.phase() != OTNN_AUTONOMY_ACTIVE_STABLE ||
!g_step7Lifecycle.hasActive() || g_step7Lifecycle.hasCandidate() ||
g_step7Lifecycle.hasPrevious()) goto fail;
g_step7Lifecycle.reset();
g_step7ActiveModel.close();
g_step7CandidateModel.close();
return true;
fail:
g_step7Lifecycle.reset();
g_step7ActiveModel.close();
g_step7CandidateModel.close();
return false;
}
/* ------------------------------------------------------------------------- */
/* v0.23 Step 10 isolated accelerated end-to-end architecture validation. */
/* ------------------------------------------------------------------------- */
static void step10CleanupValidationFiles()
{
file.unlink("v023_step10_validation_lifecycle_A.otl");
file.unlink("v023_step10_validation_lifecycle_B.otl");
file.unlink("v023_step10_validation_lifecycle_A_active.otm");
file.unlink("v023_step10_validation_lifecycle_A_candidate.otm");
file.unlink("v023_step10_validation_lifecycle_A_previous.otm");
file.unlink("v023_step10_validation_lifecycle_B_active.otm");
file.unlink("v023_step10_validation_lifecycle_B_candidate.otm");
file.unlink("v023_step10_validation_lifecycle_B_previous.otm");
file.unlink("v023_step10_validation_wide_A.otm");
file.unlink("v023_step10_validation_wide_A.ots");
file.unlink("v023_step10_validation_wide_B.otm");
file.unlink("v023_step10_validation_wide_B.ots");
file.unlink("v023_step10_validation_deep_A.otm");
file.unlink("v023_step10_validation_deep_A.ots");
file.unlink("v023_step10_validation_deep_B.otm");
file.unlink("v023_step10_validation_deep_B.ots");
}
static void step10CloseValidationObjects()
{
g_step10Training.close();
g_step10Framework.close();
g_step10Lifecycle.reset();
g_step10Model0.close();
g_step10Model1.close();
g_step10Model2.close();
}
static bool step10TrainCheckpointReload(otTinn * model,
const otNNModelDescriptor & descriptor,
const char * prefix)
{
otNNTrainingProgress p;
g_step10Training.close();
g_step10Framework.close();
g_step10Framework.init(model, &file);
if(!g_step10Framework.dataset(END_SOURCE_DATASET)) return false;
if(!g_step10Training.init(model, &g_step10Framework, &file)) return false;
if(!g_step10Training.beginExisting(descriptor, 1UL, 0.15f, 0.99f,
0x10A00000UL ^ descriptor.modelId)) return false;
if(g_step10Training.trainSamples(STEP10_TRAIN_SAMPLES) != STEP10_TRAIN_SAMPLES) return false;
if(!g_step10Training.saveCheckpoint(prefix)) return false;
g_step10Training.close();
g_step10Framework.close();
/* Reload the just-written A/B checkpoint into the same lifecycle-bound model. */
g_step10Framework.init(model, &file);
if(!g_step10Framework.dataset(END_SOURCE_DATASET)) return false;
if(!g_step10Training.init(model, &g_step10Framework, &file)) return false;
if(!g_step10Training.loadLatestCheckpoint(prefix)) return false;
memset(&p, 0, sizeof(p));
g_step10Training.progress(p);
if(p.samplesTrained != STEP10_TRAIN_SAMPLES) return false;
g_step10Training.close();
g_step10Framework.close();
return true;
}
static bool step10Q15Smoke(otTinn * model)
{
const float * input;
if(model == 0) return false;
g_step10Framework.close();
g_step10Framework.init(model, &file);
if(!g_step10Framework.dataset(END_SOURCE_DATASET)) return false;
input = g_step10Framework.input(0);
if(input == 0 || !model->prepareQ15() || model->predictQ15(input) == 0)
{
g_step10Framework.close();
return false;
}
g_step10Framework.close();
return true;
}
static bool step11AcceleratedArchitectureValidation()
{
otNNTopology activeTopology;
unsigned long heapEntry = (unsigned long)_memFree();
unsigned long heapBefore;
unsigned long heapAfterObjects;
unsigned long heapAfterCleanup;
const char * failStage = "startup";
printf("v0.23 Step 11 accelerated architecture validation: START\n");
printf(" namespace : v023_step10_validation_* (isolated regression)\n");
/* Regression namespace cleanup is performed before the heap baseline.
With otFILE v2.0.2 failed fopen() attempts release their temporary FIL
object, so this regression now requires exact heap recovery. */
step10CloseValidationObjects();
step10CleanupValidationFiles();
g_step10Storage.init(&file);
heapBefore = (unsigned long)_memFree();
printf(" heap baseline : entry=%lu warmed=%lu filesystemDelta=%ld\n",
heapEntry, heapBefore, (long)heapBefore - (long)heapEntry);
/* BF518 load() uses the otFILE pointer already bound to the model.
Windows load() opens the path directly, which hid this precondition in
the host-only Step 10 validation. Bind the filesystem exactly as the
production bootstrap does before loading saved.tinn. */
failStage = "bootstrap model init";
if(!g_step10Model0.init(END_INPUTS, END_OUTPUTS, END_BOOTSTRAP_HIDDEN, &file)) goto fail;
failStage = "bootstrap model load";
if(!g_step10Model0.load(END_BOOTSTRAP_MODEL)) goto fail;
g_step10Model0.topology(activeTopology);
otNeuralTrainingSession::makeDescriptor(g_step10ActiveD, 9100UL, 1UL, activeTopology);
failStage = "attach bootstrap ACTIVE";
if(!g_step10Lifecycle.attachActive(&g_step10Model0, g_step10ActiveD)) goto fail;
failStage = "initial lifecycle snapshot";
if(!g_step10Storage.saveSnapshot(STEP10_LIFECYCLE_PREFIX,
g_step10Lifecycle, g_step10Catalog)) goto fail;
otNeuralAutonomyController::defaultArchitecturePolicy(g_step10ArchPolicy);
/* Stage 2: 256-28-10 -> 256-48-10 using function-preserving widening. */
failStage = "stage 2 architecture plan";
if(!otNeuralAutonomyController::planCandidateTopologyAtStage(
activeTopology, 2UL, 2UL, 0UL, g_step10ArchPolicy, g_step10ArchPlan) ||
g_step10ArchPlan.stage != 2 || g_step10ArchPlan.topology.hiddenLayers != 1 ||
g_step10ArchPlan.topology.hidden[0] != 48) goto fail;
otNeuralTrainingSession::makeDescriptor(g_step10CandidateD, 9101UL, 1UL,
g_step10ArchPlan.topology);
failStage = "stage 2 candidate prepare";
if(!g_step10Lifecycle.prepareCandidate(&g_step10Model1, g_step10CandidateD, &file)) goto fail;
memset(&g_step10Warm, 0, sizeof(g_step10Warm));
failStage = "stage 2 widen warm-start";
if(!g_step10Model1.warmStartFrom(g_step10Model0, g_step10Warm) ||
g_step10Warm.mode != OTNN_WARMSTART_FUNCTION_PRESERVING_WIDEN ||
!g_step10Warm.functionPreserved) goto fail;
printf(" stage 2 WIDEN : 256-28-10 -> 256-48-10, init=WIDEN-PRESERVE\n");
failStage = "stage 2 train/checkpoint/reload";
if(!step10TrainCheckpointReload(&g_step10Model1, g_step10CandidateD,
STEP10_WIDE_TRAIN_PREFIX)) goto fail;
failStage = "stage 2 Q15";
if(!step10Q15Smoke(&g_step10Model1)) goto fail;
failStage = "stage 2 candidate snapshot";
if(!g_step10Storage.saveSnapshot(STEP10_LIFECYCLE_PREFIX,
g_step10Lifecycle, g_step10Catalog)) goto fail;
memset(&g_step10Promotion, 0, sizeof(g_step10Promotion));
failStage = "stage 2 promote";
if(!g_step10Lifecycle.promoteCandidate(g_step10Promotion)) goto fail;
failStage = "stage 2 promoted snapshot";
if(!g_step10Storage.saveSnapshot(STEP10_LIFECYCLE_PREFIX,
g_step10Lifecycle, g_step10Catalog)) goto fail;
printf(" stage 2 transaction : checkpoint + Q15 + PROMOTE + catalog commit\n");
/* Simulated reboot and explicit rollback prove the wide transaction is durable. */
g_step10Lifecycle.reset();
g_step10Model0.close(); g_step10Model1.close(); g_step10Model2.close();
failStage = "stage 2 reboot restore";
if(!g_step10Storage.loadLatestSnapshot(STEP10_LIFECYCLE_PREFIX,
g_step10Lifecycle,
&g_step10Model0, &g_step10Model1, &g_step10Model2,
g_step10Catalog)) goto fail;
failStage = "stage 2 restored PREVIOUS";
if(!g_step10Lifecycle.hasPrevious()) goto fail;
memset(&g_step10Rollback, 0, sizeof(g_step10Rollback));
failStage = "stage 2 rollback";
if(!g_step10Lifecycle.rollbackPrevious(g_step10Rollback)) goto fail;
if(g_step10Lifecycle.candidateModel() != 0) g_step10Lifecycle.candidateModel()->close();
g_step10Lifecycle.clearCandidate();
failStage = "stage 2 rollback snapshot";
if(!g_step10Storage.saveSnapshot(STEP10_LIFECYCLE_PREFIX,
g_step10Lifecycle, g_step10Catalog)) goto fail;
printf(" stage 2 reboot : RESTORE + ROLLBACK + catalog commit\n");
/* Stage 4: first true depth change, 256-48-24-10. Fresh init is intentional. */
failStage = "stage 4 active descriptor";
if(!g_step10Lifecycle.activeDescriptor(g_step10ActiveD)) goto fail;
failStage = "stage 4 architecture plan";
if(!otNeuralAutonomyController::planCandidateTopologyAtStage(
g_step10ActiveD.topology, 4UL, 4UL, 0UL,
g_step10ArchPolicy, g_step10ArchPlan) ||
g_step10ArchPlan.stage != 4 || g_step10ArchPlan.topology.hiddenLayers != 2 ||
g_step10ArchPlan.topology.hidden[0] != 48 ||
g_step10ArchPlan.topology.hidden[1] != 24) goto fail;
otNeuralTrainingSession::makeDescriptor(g_step10CandidateD, 9102UL, 1UL,
g_step10ArchPlan.topology);
failStage = "stage 4 candidate prepare";
if(!g_step10Lifecycle.prepareCandidate(&g_step10Model1, g_step10CandidateD, &file)) goto fail;
memset(&g_step10Warm, 0, sizeof(g_step10Warm));
failStage = "stage 4 fresh-init guard";
if(g_step10Model1.warmStartFrom(*g_step10Lifecycle.activeModel(), g_step10Warm)) goto fail;
printf(" stage 4 DEPTH : 256-28-10 -> 256-48-24-10, init=FRESH\n");
failStage = "stage 4 train/checkpoint/reload";
if(!step10TrainCheckpointReload(&g_step10Model1, g_step10CandidateD,
STEP10_DEEP_TRAIN_PREFIX)) goto fail;
failStage = "stage 4 Q15";
if(!step10Q15Smoke(&g_step10Model1)) goto fail;
failStage = "stage 4 candidate snapshot";
if(!g_step10Storage.saveSnapshot(STEP10_LIFECYCLE_PREFIX,
g_step10Lifecycle, g_step10Catalog)) goto fail;
/* Simulated reboot with deep CANDIDATE, then promote and persist. */
g_step10Lifecycle.reset();
g_step10Model0.close(); g_step10Model1.close(); g_step10Model2.close();
failStage = "stage 4 candidate reboot restore";
if(!g_step10Storage.loadLatestSnapshot(STEP10_LIFECYCLE_PREFIX,
g_step10Lifecycle,
&g_step10Model0, &g_step10Model1, &g_step10Model2,
g_step10Catalog)) goto fail;
failStage = "stage 4 restored CANDIDATE descriptor";
if(!g_step10Lifecycle.candidateDescriptor(g_step10RestoredD) ||
g_step10RestoredD.topology.hiddenLayers != 2 ||
g_step10RestoredD.topology.hidden[0] != 48 ||
g_step10RestoredD.topology.hidden[1] != 24) goto fail;
failStage = "stage 4 restored CANDIDATE Q15";
if(!step10Q15Smoke(g_step10Lifecycle.candidateModel())) goto fail;
memset(&g_step10Promotion, 0, sizeof(g_step10Promotion));
failStage = "stage 4 promote";
if(!g_step10Lifecycle.promoteCandidate(g_step10Promotion)) goto fail;
failStage = "stage 4 promoted snapshot";
if(!g_step10Storage.saveSnapshot(STEP10_LIFECYCLE_PREFIX,
g_step10Lifecycle, g_step10Catalog)) goto fail;
printf(" stage 4 transaction : RESTORE CANDIDATE + Q15 + PROMOTE + catalog commit\n");
/* One more reboot proves promoted deep ACTIVE is durable, then rollback. */
g_step10Lifecycle.reset();
g_step10Model0.close(); g_step10Model1.close(); g_step10Model2.close();
failStage = "stage 4 ACTIVE reboot restore";
if(!g_step10Storage.loadLatestSnapshot(STEP10_LIFECYCLE_PREFIX,
g_step10Lifecycle,
&g_step10Model0, &g_step10Model1, &g_step10Model2,
g_step10Catalog)) goto fail;
failStage = "stage 4 restored ACTIVE/PREVIOUS";
if(!g_step10Lifecycle.activeDescriptor(g_step10RestoredD) ||
g_step10RestoredD.topology.hiddenLayers != 2 || !g_step10Lifecycle.hasPrevious()) goto fail;
memset(&g_step10Rollback, 0, sizeof(g_step10Rollback));
failStage = "stage 4 rollback";
if(!g_step10Lifecycle.rollbackPrevious(g_step10Rollback)) goto fail;
if(g_step10Lifecycle.candidateModel() != 0) g_step10Lifecycle.candidateModel()->close();
g_step10Lifecycle.clearCandidate();
failStage = "stage 4 final snapshot";
if(!g_step10Storage.saveSnapshot(STEP10_LIFECYCLE_PREFIX,
g_step10Lifecycle, g_step10Catalog)) goto fail;
printf(" stage 4 reboot : RESTORE deep ACTIVE + ROLLBACK + clean catalog commit\n");
/* Step 11 requires the neural/test objects themselves to be fully
reversible. Close everything first but keep the isolated files until
the heap check has passed, so a failure retains on-SD evidence. */
step10CloseValidationObjects();
heapAfterObjects = (unsigned long)_memFree();
if(heapAfterObjects != heapBefore)
{
failStage = "post-validation object cleanup / heap stability";
goto fail_after_close;
}
/* PASS path: the regression namespace is disposable. Remove it only after
proving that model/training/Q15/dataset allocations have all returned. */
step10CleanupValidationFiles();
heapAfterCleanup = (unsigned long)_memFree();
if(heapAfterCleanup != heapBefore)
{
failStage = "post-PASS file cleanup / heap stability";
goto fail_after_close;
}
printf("v0.23 Step 11 accelerated architecture validation: PASS "
"(heap baseline=%lu objects=%lu final=%lu)\n",
heapBefore, heapAfterObjects, heapAfterCleanup);
return true;
fail:
step10CloseValidationObjects();
heapAfterObjects = (unsigned long)_memFree();
fail_after_close:
heapAfterCleanup = (unsigned long)_memFree();
printf("v0.23 Step 11 accelerated architecture validation: FAIL at %s "
"(heap entry=%lu baseline=%lu after=%lu; validation files retained)\n",
failStage != 0 ? failStage : "unknown",
heapEntry, heapBefore, heapAfterCleanup);
return false;
}
/* ------------------------------------------------------------------------- */
/* v0.25 Step 5 isolated accelerated simplification validation (BF518). */
/* */
/* Reuses the cold Step 7/Step 10 SDRAM objects so this regression adds no */
/* large persistent L1 objects. All new code is cold FAST_CODE_2. */
/* ------------------------------------------------------------------------- */
FAST_CODE_2 static void step5CleanupValidationFiles()
{
file.unlink("v025_step5_validation_lifecycle_A.otl");
file.unlink("v025_step5_validation_lifecycle_B.otl");
file.unlink("v025_step5_validation_lifecycle_A_active.otm");
file.unlink("v025_step5_validation_lifecycle_A_candidate.otm");
file.unlink("v025_step5_validation_lifecycle_A_previous.otm");
file.unlink("v025_step5_validation_lifecycle_B_active.otm");
file.unlink("v025_step5_validation_lifecycle_B_candidate.otm");
file.unlink("v025_step5_validation_lifecycle_B_previous.otm");
file.unlink("v025_step5_validation_accept_A.otm");
file.unlink("v025_step5_validation_accept_A.ots");
file.unlink("v025_step5_validation_accept_B.otm");
file.unlink("v025_step5_validation_accept_B.ots");
file.unlink("v025_step5_validation_reject_A.otm");
file.unlink("v025_step5_validation_reject_A.ots");
file.unlink("v025_step5_validation_reject_B.otm");
file.unlink("v025_step5_validation_reject_B.ots");
}
FAST_CODE_2 static bool step5ApplySimplificationDecision(float candidateAccuracy,
float candidateError,
float candidateLatencyUs,
int expectPromotion,
int expectedReason)
{
otTinn * active = g_step10Lifecycle.activeModel();
otTinn * candidate = g_step10Lifecycle.candidateModel();
otTinn * rejected;
int action;
if(active == 0 || candidate == 0 ||
!g_step10Lifecycle.activeDescriptor(g_step10ActiveD) ||
!g_step10Lifecycle.candidateDescriptor(g_step10CandidateD)) return false;
if(!active->prepareQ15() || !candidate->prepareQ15()) return false;
memset(&g_step7ActiveExecution, 0, sizeof(g_step7ActiveExecution));
memset(&g_step7CandidateExecution, 0, sizeof(g_step7CandidateExecution));
g_step7ActiveExecution.q15LatencyValid = 1;
g_step7ActiveExecution.q15LatencyUs = 10.0f;
g_step7CandidateExecution.q15LatencyValid = 1;
g_step7CandidateExecution.q15LatencyUs = candidateLatencyUs;
if(!otNeuralModelLifecycle::buildComplexityReport(active, g_step10ActiveD,
&g_step7ActiveExecution, g_step7ActiveComplexity) ||
!otNeuralModelLifecycle::buildComplexityReport(candidate, g_step10CandidateD,
&g_step7CandidateExecution, g_step7CandidateComplexity)) return false;
active->q15MemoryInfo(g_step7ActiveQ15);
candidate->q15MemoryInfo(g_step7CandidateQ15);
memset(&g_step7Validation, 0, sizeof(g_step7Validation));
g_step7Validation.valid = 1;
g_step7Validation.sampleCount = 400;
g_step7Validation.active.valid = g_step7Validation.candidate.valid = 1;
g_step7Validation.active.samples = g_step7Validation.candidate.samples = 400UL;
g_step7Validation.active.classificationAvailable = 1;
g_step7Validation.candidate.classificationAvailable = 1;
g_step7Validation.active.accuracyPercent = 90.0f;
g_step7Validation.candidate.accuracyPercent = candidateAccuracy;
g_step7Validation.active.meanAbsError = 0.100f;
g_step7Validation.candidate.meanAbsError = candidateError;
g_step7Validation.active.parameterCount = g_step7ActiveComplexity.parameters;
g_step7Validation.candidate.parameterCount = g_step7CandidateComplexity.parameters;
g_step7Validation.active.q15Prepared = g_step7Validation.candidate.q15Prepared = 1;
g_step7Validation.active.q15Evaluated = g_step7Validation.candidate.q15Evaluated = 1;
g_step7Validation.active.q15AccuracyPercent = 90.0f;
g_step7Validation.candidate.q15AccuracyPercent = candidateAccuracy;
g_step7Validation.active.q15MeanAbsError = 0.100f;
g_step7Validation.candidate.q15MeanAbsError = candidateError;
g_step7Validation.active.q15Memory = g_step7ActiveQ15;
g_step7Validation.candidate.q15Memory = g_step7CandidateQ15;
otNeuralModelLifecycle::defaultComparisonPolicy(g_step7ComparisonPolicy);
otNeuralModelLifecycle::defaultMeaningfulImprovementPolicy(g_step7ImprovementPolicy);
otNeuralModelLifecycle::defaultDominancePolicy(g_step7DominancePolicy);
if(!otNeuralModelLifecycle::evaluateMeaningfulImprovement(
g_step7Validation, g_step7ImprovementPolicy, g_step7Improvement)) return false;
if(!g_step10Lifecycle.compareCandidate(g_step7Validation,
g_step7ActiveExecution, g_step7CandidateExecution,
g_step7ComparisonPolicy, g_step7Comparison)) return false;
if(!otNeuralModelLifecycle::evaluateDominance(g_step7Comparison,
g_step7Improvement, g_step7ActiveComplexity, g_step7CandidateComplexity,
g_step7DominancePolicy, g_step7Dominance)) return false;
g_step7Controller.init(0);
otNeuralAutonomyController::defaultComplexityGatePolicy(g_step7ComplexityPolicy);
g_step7ComplexityPolicy.requireReport = 1;
g_step7Controller.setComplexityGatePolicy(&g_step7ComplexityPolicy);
g_step7Controller.setOperatingWindow(OTNN_WINDOW_MAINTENANCE);
if(!g_step7Controller.resumeTraining()) return false;
action = g_step7Controller.nextAction(g_step10Lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_VALIDATE_CANDIDATE ||
!g_step7Controller.actionCompleted(action, true)) return false;
if(!g_step7Controller.evaluatePromotionGates(g_step7Validation,
g_step7CandidateExecution, &g_step7CandidateComplexity,
&g_step7Dominance, 0, g_step7Gates)) return false;
if(!g_step7Controller.buildPromotionDecisionTrace(g_step7Validation,
g_step7ActiveComplexity, g_step7CandidateComplexity,
g_step7Improvement, g_step7Dominance, g_step7Gates, 0,
g_step7Trace)) return false;
if(expectPromotion)
{
if(g_step7Trace.reason != OTNN_DECISION_WAIT_SHADOW ||
g_step7Trace.finalDecisionKnown) return false;
action = g_step7Controller.nextAction(g_step10Lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_SHADOW_CANDIDATE ||
!g_step7Controller.actionCompleted(action, true)) return false;
memset(&g_step7Shadow, 0, sizeof(g_step7Shadow));
g_step7Shadow.valid = 1;
g_step7Shadow.activeExecutedFirst = 1;
g_step7Shadow.candidateAuthority = 0;
g_step7Shadow.samples = 400UL;
if(!g_step7Controller.evaluatePromotionGates(g_step7Validation,
g_step7CandidateExecution, &g_step7CandidateComplexity,
&g_step7Dominance, &g_step7Shadow, g_step7Gates)) return false;
if(!g_step7Controller.buildPromotionDecisionTrace(g_step7Validation,
g_step7ActiveComplexity, g_step7CandidateComplexity,
g_step7Improvement, g_step7Dominance, g_step7Gates,
&g_step7Shadow, g_step7Trace)) return false;
if(!g_step7Trace.finalDecisionKnown || !g_step7Trace.eligible ||
g_step7Trace.reason != expectedReason) return false;
action = g_step7Controller.nextAction(g_step10Lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_PROMOTE_CANDIDATE) return false;
memset(&g_step10Promotion, 0, sizeof(g_step10Promotion));
if(!g_step10Lifecycle.promoteCandidate(g_step10Promotion) ||
!g_step7Controller.actionCompleted(action, true)) return false;
return g_step7Controller.phase() == OTNN_AUTONOMY_PROBATION &&
g_step10Lifecycle.hasPrevious();
}
if(!g_step7Trace.finalDecisionKnown || g_step7Trace.eligible ||
g_step7Trace.reason != expectedReason) return false;
action = g_step7Controller.nextAction(g_step10Lifecycle, OTNN_TRAINING_COMPLETE);
if(action != OTNN_AUTONOMY_ACTION_REJECT_CANDIDATE) return false;
rejected = g_step10Lifecycle.candidateModel();
if(rejected != 0) rejected->releaseQ15();
g_step10Lifecycle.clearCandidate();
if(rejected != 0) rejected->close();
if(!g_step7Controller.actionCompleted(action, true) ||
!g_step7Controller.resumeActiveStable()) return false;
return g_step7Controller.phase() == OTNN_AUTONOMY_ACTIVE_STABLE;
}
FAST_CODE_2 static bool step5AcceleratedSimplificationValidation()
{
unsigned long heapBefore;
unsigned long heapAfter;
unsigned long acceptedActiveId = 0UL;
const char * failStage = "startup";
int action;
printf("v0.25 Step 5 accelerated simplification validation: START\n");
printf(" namespace : v025_step5_validation_* (isolated regression)\n");
step10CloseValidationObjects();
step5CleanupValidationFiles();
g_step10Storage.init(&file);
heapBefore = (unsigned long)_memFree();
/* Bootstrap the historical ACTIVE exactly like production. */
failStage = "bootstrap init";
if(!g_step10Model0.init(END_INPUTS, END_OUTPUTS, END_BOOTSTRAP_HIDDEN, &file)) goto fail;
failStage = "bootstrap load";
if(!g_step10Model0.load(END_BOOTSTRAP_MODEL)) goto fail;
g_step10Model0.topology(g_step7ActiveTopology);
otNeuralTrainingSession::makeDescriptor(g_step10ActiveD, 92500UL, 1UL,
g_step7ActiveTopology);
failStage = "attach ACTIVE";
if(!g_step10Lifecycle.attachActive(&g_step10Model0, g_step10ActiveD)) goto fail;
failStage = "initial snapshot";
if(!g_step10Storage.saveSnapshot(STEP5_LIFECYCLE_PREFIX,
g_step10Lifecycle, g_step10Catalog)) goto fail;
/* A: real prune/train/checkpoint/Q15 -> promote -> persist -> reboot ->
restore -> probation acceptance. */
otNeuralAutonomyController::defaultSimplificationPolicy(g_v025SimplificationPolicy);
failStage = "accept plan";
if(!otNeuralAutonomyController::planSimplerTopology(g_step7ActiveTopology, 0UL,
g_v025SimplificationPolicy, g_v025SimplificationPlan) ||
!g_v025SimplificationPlan.valid || !g_v025SimplificationPlan.changed ||
g_v025SimplificationPlan.topology.hiddenLayers != 1 ||
g_v025SimplificationPlan.topology.hidden[0] != 24) goto fail;
otNeuralTrainingSession::makeDescriptor(g_step10CandidateD, 92501UL, 1UL,
g_v025SimplificationPlan.topology);
failStage = "accept candidate prepare";
if(!g_step10Lifecycle.prepareCandidate(&g_step10Model1,
g_step10CandidateD, &file)) goto fail;
memset(&g_step10Warm, 0, sizeof(g_step10Warm));
failStage = "accept PRUNE-COPY";
if(!g_step10Model1.warmStartFrom(g_step10Model0, g_step10Warm) ||
g_step10Warm.mode != OTNN_WARMSTART_STRUCTURED_PRUNE_COPY ||
g_step10Warm.functionPreserved) goto fail;
failStage = "accept checkpoint/reload";
if(!step10TrainCheckpointReload(&g_step10Model1, g_step10CandidateD,
STEP5_ACCEPT_TRAIN_PREFIX)) goto fail;
failStage = "accept Q15";
if(!step10Q15Smoke(&g_step10Model1)) goto fail;
failStage = "accept pre-promotion snapshot";
if(!g_step10Storage.saveSnapshot(STEP5_LIFECYCLE_PREFIX,
g_step10Lifecycle, g_step10Catalog)) goto fail;
failStage = "accept decision/promote";
if(!step5ApplySimplificationDecision(90.0f, 0.100f, 8.0f, 1,
OTNN_DECISION_PROMOTE_PARETO)) goto fail;
failStage = "accept promoted snapshot";
if(!g_step10Storage.saveSnapshot(STEP5_LIFECYCLE_PREFIX,
g_step10Lifecycle, g_step10Catalog)) goto fail;
/* Simulated reboot and durable probation. */
step10CloseValidationObjects();
failStage = "accept reboot restore";
if(!g_step10Storage.loadLatestSnapshot(STEP5_LIFECYCLE_PREFIX,
g_step10Lifecycle, &g_step10Model0, &g_step10Model1,
&g_step10Model2, g_step10Catalog)) goto fail;
if(!g_step10Lifecycle.activeDescriptor(g_step10RestoredD) ||
g_step10RestoredD.topology.hiddenLayers != 1 ||
g_step10RestoredD.topology.hidden[0] != 24 ||
!g_step10Lifecycle.hasPrevious() || g_step10Lifecycle.hasCandidate()) goto fail;
acceptedActiveId = g_step10RestoredD.modelId;
failStage = "accept reboot Q15";
if(g_step10Lifecycle.activeModel() == 0 ||
!g_step10Lifecycle.activeModel()->prepareQ15()) goto fail;
g_step7Controller.init(0);
failStage = "accept probation resume";
if(!g_step7Controller.resumeProbation() || !g_step7Controller.acceptProbation()) goto fail;
failStage = "accept retire PREVIOUS";
if(!g_step10Lifecycle.retirePrevious()) goto fail;
g_step10Model2.close();
failStage = "accept probation snapshot";
if(!g_step10Storage.saveSnapshot(STEP5_LIFECYCLE_PREFIX,
g_step10Lifecycle, g_step10Catalog)) goto fail;
g_step7Controller.markCatalogCommitted();
printf(" accept/persist/reboot/probation : 256-28-10 -> 256-24-10 PASS\n");
/* B: a second real shrink is checkpointed/Q15-ready but hard quality
rejection must preserve ACTIVE; cooldown must block immediate retry. */
failStage = "reject active descriptor";
if(!g_step10Lifecycle.activeDescriptor(g_step10ActiveD)) goto fail;
failStage = "reject plan";
if(!otNeuralAutonomyController::planSimplerTopology(g_step10ActiveD.topology,
0UL, g_v025SimplificationPolicy, g_v025SimplificationPlan) ||
!g_v025SimplificationPlan.valid || !g_v025SimplificationPlan.changed) goto fail;
otNeuralTrainingSession::makeDescriptor(g_step10CandidateD, 92502UL, 1UL,
g_v025SimplificationPlan.topology);
failStage = "reject candidate prepare";
if(!g_step10Lifecycle.prepareCandidate(&g_step10Model1,
g_step10CandidateD, &file)) goto fail;
memset(&g_step10Warm, 0, sizeof(g_step10Warm));
failStage = "reject PRUNE-COPY";
if(!g_step10Model1.warmStartFrom(*g_step10Lifecycle.activeModel(),
g_step10Warm) ||
g_step10Warm.mode != OTNN_WARMSTART_STRUCTURED_PRUNE_COPY) goto fail;
failStage = "reject checkpoint/reload";
if(!step10TrainCheckpointReload(&g_step10Model1, g_step10CandidateD,
STEP5_REJECT_TRAIN_PREFIX)) goto fail;
failStage = "reject Q15";
if(!step10Q15Smoke(&g_step10Model1)) goto fail;
failStage = "reject decision";
if(!step5ApplySimplificationDecision(87.0f, 0.140f, 7.0f, 0,
OTNN_DECISION_REJECT_FLOAT_QUALITY)) goto fail;
if(!g_step10Lifecycle.activeDescriptor(g_step10RestoredD) ||
g_step10RestoredD.modelId != acceptedActiveId ||
g_step10Lifecycle.hasCandidate() || g_step10Lifecycle.hasPrevious()) goto fail;
otNeuralAutonomyController::defaultSimplificationTriggerPolicy(g_v025TriggerPolicy);
memset(&g_v025TriggerContext, 0, sizeof(g_v025TriggerContext));
g_v025TriggerContext.autonomyPhase = OTNN_AUTONOMY_ACTIVE_STABLE;
g_v025TriggerContext.monitorState = OTNN_MONITOR_GOOD;
g_v025TriggerContext.stableSamples = g_v025TriggerPolicy.minimumStableSamples;
g_v025TriggerContext.activeAgeSamples = g_v025TriggerPolicy.minimumActiveAgeSamples;
g_v025TriggerContext.previousAttemptKnown = 1;
g_v025TriggerContext.samplesSincePreviousAttempt = g_v025TriggerPolicy.cooldownSamples - 1UL;
failStage = "reject cooldown";
if(!otNeuralAutonomyController::evaluateSimplificationTrigger(
g_v025SimplificationPlan, g_v025TriggerContext,
g_v025TriggerPolicy, g_v025TriggerReport) ||
g_v025TriggerReport.eligible ||
g_v025TriggerReport.reason != OTNN_SIMPLIFY_TRIGGER_COOLDOWN) goto fail;
failStage = "reject snapshot";
if(!g_step10Storage.saveSnapshot(STEP5_LIFECYCLE_PREFIX,
g_step10Lifecycle, g_step10Catalog)) goto fail;
step10CloseValidationObjects();
failStage = "reject reboot restore";
if(!g_step10Storage.loadLatestSnapshot(STEP5_LIFECYCLE_PREFIX,
g_step10Lifecycle, &g_step10Model0, &g_step10Model1,
&g_step10Model2, g_step10Catalog)) goto fail;
if(!g_step10Lifecycle.activeDescriptor(g_step10RestoredD) ||
g_step10RestoredD.modelId != acceptedActiveId ||
g_step10Lifecycle.hasCandidate() || g_step10Lifecycle.hasPrevious()) goto fail;
printf(" reject + cooldown + reboot : ACTIVE preserved PASS\n");
/* C: degradation during a simplification preempts it and returns control
to the normal RETRAIN_REQUIRED chain. */
failStage = "preempt active descriptor";
if(!g_step10Lifecycle.activeDescriptor(g_step10ActiveD)) goto fail;
failStage = "preempt plan";
if(!otNeuralAutonomyController::planSimplerTopology(g_step10ActiveD.topology,
0UL, g_v025SimplificationPolicy, g_v025SimplificationPlan) ||
!g_v025SimplificationPlan.valid || !g_v025SimplificationPlan.changed) goto fail;
otNeuralTrainingSession::makeDescriptor(g_step10CandidateD, 92503UL, 1UL,
g_v025SimplificationPlan.topology);
failStage = "preempt candidate prepare";
if(!g_step10Lifecycle.prepareCandidate(&g_step10Model1,
g_step10CandidateD, &file)) goto fail;
memset(&g_step10Warm, 0, sizeof(g_step10Warm));
failStage = "preempt PRUNE-COPY";
if(!g_step10Model1.warmStartFrom(*g_step10Lifecycle.activeModel(),
g_step10Warm)) goto fail;
g_step7Controller.init(0);
g_step7Controller.setOperatingWindow(OTNN_WINDOW_MAINTENANCE);
if(!g_step7Controller.resumeTraining()) goto fail;
if(!(OTNN_MONITOR_WARNING > g_v025TriggerPolicy.maximumMonitorState)) goto fail;
g_step10Lifecycle.clearCandidate();
g_step10Model1.close();
if(!g_step7Controller.actionCompleted(OTNN_AUTONOMY_ACTION_REJECT_CANDIDATE, true) ||
!g_step7Controller.resumeActiveStable()) goto fail;
g_step7Controller.observeMonitorState(OTNN_MONITOR_RETRAIN_REQUIRED);
action = g_step7Controller.nextAction(g_step10Lifecycle, OTNN_TRAINING_EMPTY);
if(action != OTNN_AUTONOMY_ACTION_CREATE_CANDIDATE) goto fail;
if(!g_step10Lifecycle.activeDescriptor(g_step10RestoredD) ||
g_step10RestoredD.modelId != acceptedActiveId || g_step10Lifecycle.hasCandidate()) goto fail;
printf(" monitor preemption -> retrain : PASS\n");
step10CloseValidationObjects();
heapAfter = (unsigned long)_memFree();
if(heapAfter != heapBefore)
{
failStage = "heap recovery";
goto fail_after_close;
}
step5CleanupValidationFiles();
heapAfter = (unsigned long)_memFree();
if(heapAfter != heapBefore)
{
failStage = "post-file-cleanup heap recovery";
goto fail_after_close;
}
printf("v0.25 Step 5 accelerated simplification validation: PASS "
"(heap baseline=%lu final=%lu)\n", heapBefore, heapAfter);
return true;
fail:
step10CloseValidationObjects();
fail_after_close:
heapAfter = (unsigned long)_memFree();
printf("v0.25 Step 5 accelerated simplification validation: FAIL at %s "
"(heap baseline=%lu final=%lu; validation files retained)\n",
failStage != 0 ? failStage : "unknown", heapBefore, heapAfter);
return false;
}
/* ------------------------------------------------------------------------- */
/* Setup */
/* ------------------------------------------------------------------------- */
static bool initializeEndurance()
{
otNeuralMonitorConfig mc;
otNNAutonomyPolicy ap;
otNNComplexityGatePolicy cp;
otNNModelDescriptor d;
int y, mo, da;
U8 h, mi, se;
if(!topologyStep11CoreSelfTest())
{
printf("v0.25 consolidated R3 core self-test: FAIL\n");
return false;
}
printf("v0.25 consolidated R3 SIMMEM1 BOOTFIX3 SIGNATURE2 core self-test: PASS\n");
#if OTTINN_RUN_POLICY_REGRESSION
if(!step7DeterministicDecisionPathSelfTest(&file) ||
!step3SimplificationTriggerSelfTest() ||
!step4SimplificationLifecycleSelfTest(&file) ||
!step5AcceleratedSimplificationValidation())
return false;
printf("v0.25 policy/simplification regression: PASS\n");
#else
printf("v0.25 policy/simplification regression: available, disabled at boot\n");
#endif
#if OTTINN_RUN_BOOT_REGRESSION
if(!step11AcceleratedArchitectureValidation()) return false;
printf("v0.23 accelerated regression: PASS\n");
#else
printf("v0.23 accelerated regression: available, disabled at boot\n");
#endif
loadEnduranceState();
rtcInitOnce();
if(!openEnduranceLog()) return false;
logPrefix("BOOT_STATE");
file.fprintf(g_logFile,
"A[exists=%lu valid=%lu version=%lu seq=%lu] B[exists=%lu valid=%lu version=%lu seq=%lu] selected=%s",
g_stateAExists, g_stateAValid, g_stateAVersion, g_stateASequence,
g_stateBExists, g_stateBValid, g_stateBVersion, g_stateBSequence,
g_stateSelectedSlot == 1UL ? "A" :
(g_stateSelectedSlot == 2UL ? "B" : "FRESH"));
logEnd(1);
printf("[BOOT_STATE] A exists=%lu valid=%lu v=%lu seq=%lu; B exists=%lu valid=%lu v=%lu seq=%lu; selected=%s\n",
g_stateAExists, g_stateAValid, g_stateAVersion, g_stateASequence,
g_stateBExists, g_stateBValid, g_stateBVersion, g_stateBSequence,
g_stateSelectedSlot == 1UL ? "A" :
(g_stateSelectedSlot == 2UL ? "B" : "FRESH"));
printf("[BOOT_STATE] reader=otFILE::freadline_v2.0.2 checksum=VERIFIED\n");
if((g_stateAExists || g_stateBExists) && !g_enduranceStateRestored)
{
logSimple("ERROR", "endurance state files exist but neither A nor B is valid; refusing partial restore", 1);
printf("BOOT ERROR: endurance state A/B invalid; SD left untouched.\n");
return false;
}
RtcGetDate(&y, &mo, &da);
RtcGetTime(&h, &mi, &se);
logPrefix("SESSION");
file.fprintf(g_logFile,
"START version=v0.25-consolidated-R3-SIMMEM1-BOOTFIX3-SIGNATURE2 seed=0x%08lX stateSeq=%lu worldCycle=%lu local=%lu archFailures=%lu nextStage=%lu resourceCap=%lu saturated=%lu attemptedMask=0x%03lX outcomeBits=0x%05lX simplify[stable=%lu activeAge=%lu prevAttempt=%lu sinceAttempt=%lu mode=%lu attempts=%lu promotions=%lu rejections=%lu rollbacks=%lu] rtcInitialized=%d date=%04d/%02d/%02d time=%02d:%02d:%02d",
END_WORLD_BASE_SEED, g_state.sequence, g_state.worldCycle,
g_state.worldLocalTick, g_state.architectureFailures,
g_state.architectureNextStage, g_state.architectureParameterCeiling,
g_state.architectureSaturated, g_state.architectureAttemptedMask,
g_state.architectureOutcomeBits,
g_state.simplificationStableSamples,
g_state.simplificationActiveAgeSamples,
g_state.simplificationPreviousAttemptKnown,
g_state.simplificationSamplesSinceAttempt,
g_state.simplificationLifecycleMode,
g_state.simplificationAttempts,
g_state.simplificationPromotions,
g_state.simplificationRejections,
g_state.simplificationRollbacks, g_rtcWasInitialized,
y, mo, da, (int)h, (int)mi, (int)se);
logEnd(1);
StartTimer(END_BENCH_TIMER);
if(!bootstrapOrRestoreLifecycle()) return false;
if(g_lifecycleRestoredFromCatalog && !g_enduranceStateRestored)
{
logSimple("ERROR", "lifecycle restored but endurance state is missing; refusing partial restore", 1);
printf("BOOT ERROR: lifecycle catalog exists but endurance state is missing.\n");
return false;
}
if(!g_lifecycleRestoredFromCatalog && g_enduranceStateRestored)
{
logSimple("ERROR", "endurance state restored but lifecycle catalog is missing; refusing partial restore", 1);
printf("BOOT ERROR: endurance state exists but lifecycle catalog is missing.\n");
return false;
}
{
unsigned long activeId = 0UL;
unsigned long candidateId = 0UL;
unsigned long previousId = 0UL;
const unsigned long roleMax = largestRoleModelId();
const unsigned long before = g_state.nextModelId;
if(g_lifecycle.activeDescriptor(d)) activeId = d.modelId;
if(g_lifecycle.candidateDescriptor(d)) candidateId = d.modelId;
if(g_lifecycle.previousDescriptor(d)) previousId = d.modelId;
logPrefix("BOOT_ROLES");
file.fprintf(g_logFile,
"active=%lu candidate=%lu previous=%lu simplifyMode=%lu stateSeq=%lu",
activeId, candidateId, previousId,
g_state.simplificationLifecycleMode, g_state.sequence);
logEnd(1);
printf("[BOOT_ROLES] active=%lu candidate=%lu previous=%lu simplifyMode=%lu stateSeq=%lu\n",
activeId, candidateId, previousId,
g_state.simplificationLifecycleMode, g_state.sequence);
if(g_state.nextModelId <= roleMax)
g_state.nextModelId = roleMax + 1UL;
logPrefix("BOOT_COHERENCE");
file.fprintf(g_logFile,
"stateRestored=%lu catalogRestored=%lu roleMaxModelId=%lu nextModelId=%lu->%lu",
g_enduranceStateRestored, g_lifecycleRestoredFromCatalog,
roleMax, before, g_state.nextModelId);
logEnd(1);
printf("[BOOT_COHERENCE] state=%s catalog=%s roleMax=%lu nextModelId=%lu%s\n",
g_enduranceStateRestored ? "RESTORED" : "FRESH",
g_lifecycleRestoredFromCatalog ? "RESTORED" : "BOOTSTRAP",
roleMax, g_state.nextModelId,
before != g_state.nextModelId ? " (RECONCILED)" : "");
}
if(g_state.simplificationLifecycleMode == 2UL &&
g_lifecycle.hasCandidate() && !g_lifecycle.hasPrevious())
{
g_state.simplificationLifecycleMode = 1UL;
logSimple("BOOT", "simplification state reconciled: probation marker -> candidate transaction", 1);
}
else if(g_state.simplificationLifecycleMode == 1UL &&
g_lifecycle.hasPrevious() && !g_lifecycle.hasCandidate())
{
g_state.simplificationLifecycleMode = 2UL;
logSimple("BOOT", "simplification state reconciled: candidate marker -> probation", 1);
}
else if(g_state.simplificationLifecycleMode != 0UL &&
!g_lifecycle.hasCandidate() && !g_lifecycle.hasPrevious())
{
g_state.simplificationLifecycleMode = 0UL;
g_state.simplificationPreviousAttemptKnown = 1UL;
g_state.simplificationSamplesSinceAttempt = 0UL;
resetSimplificationDwell();
logSimple("BOOT", "orphan simplification marker cleared; cooldown restarted", 1);
}
g_sourceFramework.close();
g_sourceFramework.init(g_lifecycle.activeModel(), &file);
if(!g_sourceFramework.dataset(END_SOURCE_DATASET)) return false;
if(!g_world.init(END_INPUTS, END_OUTPUTS, (unsigned int)END_WORLD_BASE_SEED)) return false;
if(!configureWorldCycle(g_state.worldCycle)) return false;
otNeuralMonitor::defaultConfig(mc);
mc.referenceSamples = 500UL;
mc.evaluationPeriod = 32UL;
mc.degradedRetrainEvaluations = END_DEGRADED_RETRAIN_EVALS;
if(!g_monitor.init(END_INPUTS, &mc)) return false;
logPrefix("POLICY");
file.fprintf(g_logFile,
"monitor errorRetrainRatio=%.2f persistentDegraded=%lu evaluations (~%lu samples)",
(double)mc.errorRetrainRatio, mc.degradedRetrainEvaluations,
mc.degradedRetrainEvaluations * mc.evaluationPeriod);
logEnd(1);
otNeuralAutonomyController::defaultArchitecturePolicy(g_architecturePolicy);
otNeuralAutonomyController::defaultSimplificationPolicy(g_simplificationPolicy);
otNeuralAutonomyController::defaultSimplificationTriggerPolicy(g_simplificationTriggerPolicy);
otNeuralAutonomyController::defaultPolicy(ap);
ap.minimumValidationSamples = 200UL;
ap.minimumShadowSamples = 200UL;
ap.maximumAccuracyDropPoints = 0.50f;
ap.maximumQ15AccuracyDropPoints = 0.50f;
ap.maximumMeanErrorIncreaseRatio = 0.05f;
ap.maximumQ15MeanErrorIncreaseRatio = 0.05f;
ap.maximumQ15LatencyUs = 1500.0f;
g_controller.init(&ap);
otNeuralAutonomyController::defaultComplexityGatePolicy(cp);
cp.requireReport = 1;
cp.maximumHiddenLayers = g_architecturePolicy.maxHiddenLayers;
cp.maximumHiddenWidth = g_architecturePolicy.maxHiddenWidth;
cp.maximumParameters = g_architecturePolicy.maximumParameters;
g_controller.setComplexityGatePolicy(&cp);
logPrefix("POLICY");
file.fprintf(g_logFile,
"architecture enabled=%d maxHidden=%d maxWidth=%d quantum=%d maxParams=%lu qualityFailures=%lu nextStage=%lu learnedParamCap=%lu saturated=%lu attemptedMask=0x%03lX outcomeBits=0x%05lX candidateInit=clone/widen-preserve/prune-copy/fresh-depth",
g_architecturePolicy.enabled, g_architecturePolicy.maxHiddenLayers,
g_architecturePolicy.maxHiddenWidth, g_architecturePolicy.widthQuantum,
g_architecturePolicy.maximumParameters, g_state.architectureFailures,
g_state.architectureNextStage, g_state.architectureParameterCeiling,
g_state.architectureSaturated, g_state.architectureAttemptedMask,
g_state.architectureOutcomeBits);
logEnd(1);
logPrefix("POLICY");
file.fprintf(g_logFile,
"simplification planner[enabled=%d minHidden=%d minWidth=%d quantum=%d maxSteps=%lu] trigger[enabled=%d maxMonitor=%s stable=%lu activeAge=%lu cooldown=%lu minParamReduction=%.3f autonomous=1]",
g_simplificationPolicy.enabled,
g_simplificationPolicy.minimumHiddenLayers,
g_simplificationPolicy.minimumHiddenWidth,
g_simplificationPolicy.widthQuantum,
g_simplificationPolicy.maximumSteps,
g_simplificationTriggerPolicy.enabled,
monitorName(g_simplificationTriggerPolicy.maximumMonitorState),
g_simplificationTriggerPolicy.minimumStableSamples,
g_simplificationTriggerPolicy.minimumActiveAgeSamples,
g_simplificationTriggerPolicy.cooldownSamples,
(double)g_simplificationTriggerPolicy.minimumParameterReductionRatio);
logEnd(1);
logPrefix("POLICY");
file.fprintf(g_logFile,
"worldMode=AGGRESSIVE calmTailEnabled=%d signature=POLICY_INTERFACE signatureDecisionInput=1 stable=%lu activeAge=%lu cooldown=%lu",
END_CALM_TAIL_ENABLED,
g_simplificationTriggerPolicy.minimumStableSamples,
g_simplificationTriggerPolicy.minimumActiveAgeSamples,
g_simplificationTriggerPolicy.cooldownSamples);
logEnd(1);
logPrefix("POLICY");
file.fprintf(g_logFile,
"complexityGates requireReport=%d maxHidden=%d maxWidth=%d maxParams=%lu maxMACs=%lu maxFloatBytes=%lu maxTrainBytes=%lu maxQ15Bytes=%lu maxQ15Normal=%lu requireFloatLatency=%d maxFloatLatency=%.3f (zero maxima=unbounded)",
cp.requireReport, cp.maximumHiddenLayers, cp.maximumHiddenWidth,
cp.maximumParameters, cp.maximumMacsPerInference,
cp.maximumFloatRuntimeBytes, cp.maximumTrainingWorkspaceBytes,
cp.maximumQ15RuntimeBytes, cp.maximumQ15NormalBytes,
cp.requireFloatLatency, (double)cp.maximumFloatLatencyUs);
logEnd(1);
otNeuralModelLifecycle::defaultMeaningfulImprovementPolicy(g_improvementPolicy);
logPrefix("POLICY");
file.fprintf(g_logFile,
"meaningfulImprovement floatAccGainPoints=%.3f floatErrorReductionRatio=%.4f q15AccGainPoints=%.3f q15ErrorReductionRatio=%.4f feedsDominance=1",
(double)g_improvementPolicy.minimumFloatAccuracyGainPoints,
(double)g_improvementPolicy.minimumFloatMeanErrorReductionRatio,
(double)g_improvementPolicy.minimumQ15AccuracyGainPoints,
(double)g_improvementPolicy.minimumQ15MeanErrorReductionRatio);
logEnd(1);
otNeuralModelLifecycle::defaultComparisonPolicy(g_comparisonPolicy);
otNeuralModelLifecycle::defaultDominancePolicy(g_dominancePolicy);
logPrefix("POLICY");
file.fprintf(g_logFile,
"dominance maxParamInc=%.3f maxMACInc=%.3f maxFloatBytesInc=%.3f maxWorkspaceInc=%.3f maxQ15BytesInc=%.3f maxQ15LatencyInc=%.3f promotionGate=1",
(double)g_dominancePolicy.maximumParameterIncreaseRatio,
(double)g_dominancePolicy.maximumMacIncreaseRatio,
(double)g_dominancePolicy.maximumFloatRuntimeIncreaseRatio,
(double)g_dominancePolicy.maximumTrainingWorkspaceIncreaseRatio,
(double)g_dominancePolicy.maximumQ15RuntimeIncreaseRatio,
(double)g_dominancePolicy.maximumQ15LatencyIncreaseRatio);
logEnd(1);
logPrefix("POLICY");
file.fprintf(g_logFile,
"TOPPA_HARDWARE_BF518 deploymentLatencyPatch=%d reason=scarce-fast-memory shadowLatencyDiagnosticOnly=1 promotionLatency=as-if-promoted candidateActuationDuringPatch=0 restoreOrder=ACTIVE-then-CANDIDATE",
END_BF518_DEPLOYMENT_LATENCY_PATCH);
logEnd(1);
if(g_lifecycle.hasPrevious())
{
if(!g_controller.resumeProbation()) return false;
logSimple("BOOT", "restored PREVIOUS -> resume probation", 1);
}
else if(g_lifecycle.hasCandidate())
{
const int simplificationCandidate =
g_state.simplificationLifecycleMode == 1UL ? 1 : 0;
if(!simplificationCandidate)
g_controller.observeMonitorState(OTNN_MONITOR_RETRAIN_REQUIRED);
if(resumeCandidateTrainingIfPossible())
{
if(!g_controller.resumeTraining()) return false;
logSimple("BOOT", simplificationCandidate ?
"simplification candidate checkpoint resumed" :
"candidate checkpoint resumed", 1);
}
else
{
otTinn * c = g_lifecycle.candidateModel();
if(c != 0) c->releaseQ15();
g_lifecycle.clearCandidate();
if(c != 0) c->close();
if(!commitLifecycle(simplificationCandidate ?
"discard-unresumable-simplification-candidate" :
"discard-unresumable-candidate")) return false;
if(simplificationCandidate)
{
g_state.simplificationLifecycleMode = 0UL;
++g_state.simplificationRejections;
g_state.simplificationPreviousAttemptKnown = 1UL;
g_state.simplificationSamplesSinceAttempt = 0UL;
resetSimplificationDwell();
if(!g_controller.resumeActiveStable()) return false;
}
logSimple("BOOT", simplificationCandidate ?
"simplification candidate could not resume; discarded and cooldown restarted" :
"candidate existed but checkpoint/dataset could not resume; discarded", 1);
}
}
if(!saveEnduranceState()) return false;
printf("\n=== otTINN v0.25 CONSOLIDATED R3 SIMMEM1 BOOTFIX3 SIGNATURE2 ===\n");
printf("RTC : %04d/%02d/%02d %02d:%02d:%02d%s\n",
y, mo, da, (int)h, (int)mi, (int)se,
g_rtcWasInitialized ? " (initialized)" : "");
printf("Log : %s (APPEND)\n", END_LOG_FILE);
printf("Lifecycle : A/B persistent, prefix=%s\n", END_LIFECYCLE_PREFIX);
printf("Topology core : generic float train/checkpoint + Q15 inference, 1..4 hidden layers\n");
printf("Architecture policy : outcome-aware bounded escalation, failures=%lu nextStage=%lu cap=%lu attempted=0x%03lX outcomes=0x%05lX%s\n",
g_state.architectureFailures, g_state.architectureNextStage,
g_state.architectureParameterCeiling, g_state.architectureAttemptedMask,
g_state.architectureOutcomeBits,
g_state.architectureSaturated ? " SATURATED" : "");
printf("Architecture bounds : maxHidden=%d maxWidth=%d maxParams=%lu\n",
g_architecturePolicy.maxHiddenLayers, g_architecturePolicy.maxHiddenWidth,
g_architecturePolicy.maximumParameters);
printf("Candidate init : clone / widen-preserve / structured PRUNE-COPY / fresh on depth change\n");
printf("Complexity report : parameters/MACs/float/Q15/workspace/topology/latency; descriptive only\n");
printf("Complexity gates : independent absolute target limits; report required; no aggregate score\n");
printf("Quality thresholds : +0.25 accuracy points / >=2%% mean-error reduction; feeds dominance gate\n");
printf("Dominance promotion : Candidate Pareto OR meaningful gain with bounded <=2x relative cost\n");
printf("Decision logging : explicit reason + quality/cost deltas; no decision-policy change\n");
printf("Decision-path test : 4 deterministic policy cases validated through lifecycle roles\n");
printf("Simplification planner : deepest-first one-quantum narrowing, then deepest-layer removal; autonomous\n");
printf("Simplification init : structured PRUNE-COPY by outgoing-weight salience; deterministic, not exact\n");
printf("Simplification trigger : stable>=%lu activeAge>=%lu cooldown>=%lu savings>=%.1f%%; AUTONOMOUS\n",
g_simplificationTriggerPolicy.minimumStableSamples,
g_simplificationTriggerPolicy.minimumActiveAgeSamples,
g_simplificationTriggerPolicy.cooldownSamples,
(double)(100.0f * g_simplificationTriggerPolicy.minimumParameterReductionRatio));
printf("Simplification lifecycle: persistent counters/mode; monitor preemption; neutral reject/rollback\n");
#if OTTINN_RUN_POLICY_REGRESSION
printf("Simplification test : boot regression PASS\n");
#else
printf("Simplification test : validated; optional boot regression disabled\n");
#endif
#if OTTINN_RUN_POLICY_REGRESSION
printf("Policy regression : Step7 + v0.25 Step3/4/5 PASS at boot\n");
#else
printf("Policy regression : available; compile with OTTINN_RUN_POLICY_REGRESSION=1\n");
#endif
#if OTTINN_RUN_BOOT_REGRESSION
printf("Architecture regression: stage2 widen + stage4 depth + exact heap cleanup PASS\n");
#else
printf("Architecture regression: available; compile with OTTINN_RUN_BOOT_REGRESSION=1\n");
#endif
printf("otFILE : v2.0.2 required (safe freadline + failed-fopen fix)\n");
printf("World seed : 0x%08lX\n", END_WORLD_BASE_SEED);
printf("World cycle : %lu samples\n", END_WORLD_CYCLE_SAMPLES);
printf("World mode : normal R3 aggressive deterministic perturbation; calm-tail disabled\n");
printf("Model signature : SIGNATURE2 policy interface; no score; decision semantics unchanged\n");
printf("Policy : UNCHANGED stable>=%lu activeAge>=%lu cooldown>=%lu\n",
g_simplificationTriggerPolicy.minimumStableSamples,
g_simplificationTriggerPolicy.minimumActiveAgeSamples,
g_simplificationTriggerPolicy.cooldownSamples);
printf("Training : %lu epochs, %lu samples/block, checkpoint every %lu\n",
END_TRAIN_EPOCHS, END_TRAIN_BLOCK_SAMPLES, END_CHECKPOINT_PERIOD);
printf("Telemetry : every %lu samples; fsync every %lu + critical events\n",
END_TELEMETRY_PERIOD, END_LOG_SYNC_PERIOD);
printf("Console : ? = live status / ESC = clean checkpoint+commit+stop\n");
printf("Latency HW patch : TOPPA BF518; promotion uses as-if-ACTIVE deployment latency\n");
printf("Simplify outcome mem : SIMMEM1 persistent parent+target block after REJECT/ROLLBACK\n");
printf(" shadow latency remains diagnostic only\n");
printf("Stack policy : persistent/work objects outside 4 KiB stack\n");
printf("===============================================\n\n");
return true;
}
/* ------------------------------------------------------------------------- */
/* One endless operating sample */
/* ------------------------------------------------------------------------- */
static bool enduranceStep()
{
const int row = g_sourceFramework.rows() > 0 ?
(int)(g_state.tickLo % (unsigned long)g_sourceFramework.rows()) : 0;
const short * prediction;
float sampleError = 0.0f;
int k;
int window;
int monitorState;
otNeuralMonitorInfo mi;
if(g_sourceFramework.rows() <= 0 || g_lifecycle.activeModel() == 0) return false;
if(g_state.worldLocalTick == 0UL && g_state.tickLo != 0UL)
{
if(!configureWorldCycle(g_state.worldCycle)) return false;
if(!saveEnduranceState()) return false;
}
if(!g_world.applyAt((otNeuralScenarioTick)g_state.worldLocalTick,
g_sourceFramework.input(row), g_sourceFramework.target(row),
g_worldInput, g_worldTarget))
return false;
if(!g_lifecycle.activeModel()->quantizeInputQ15(g_worldInput, g_qInput)) return false;
prediction = g_lifecycle.activeModel()->predictQ15Raw(g_qInput);
if(prediction == 0) return false;
for(k = 0; k < END_OUTPUTS; ++k)
{
float d;
g_predictionFloat[k] = (float)prediction[k] / 32767.0f;
d = g_worldTarget[k] - g_predictionFloat[k];
if(d < 0.0f) d = -d;
sampleError += d;
}
sampleError /= (float)END_OUTPUTS;
if(!g_monitor.observe((otNeuralMonitorTick)g_state.tickLo,
g_worldInput, true, sampleError))
return false;
monitorState = (int)g_monitor.state();
g_controller.observeMonitorState(monitorState);
updateSimplificationCounters(monitorState);
if(!abortSimplificationIfMonitorUnstable(monitorState)) return false;
if(monitorState != g_previousMonitorState)
{
g_monitor.info(mi);
logPrefix("MONITOR");
file.fprintf(g_logFile,
"state=%s err=%.7f ratio=%.3f inputMean=%.3f inputVar=%.3f",
monitorName(monitorState), (double)mi.recentMeanError,
(double)mi.errorRatio, (double)mi.inputMeanDrift,
(double)mi.inputVarianceDrift);
logEnd(1);
printf("[MONITOR] %s\n", monitorName(monitorState));
g_previousMonitorState = monitorState;
}
window = scheduledWindow();
g_controller.setOperatingWindow(window);
if(window != g_previousWindow)
{
logPrefix("WINDOW");
file.fprintf(g_logFile, "window=%s",
otNeuralAutonomyController::windowName(window));
logEnd(0);
g_previousWindow = window;
}
if(g_controller.phase() == OTNN_AUTONOMY_PROBATION)
{
if(g_monitor.referenceReady() && monitorState <= OTNN_MONITOR_NOTICE)
++g_probationGoodSamples;
else if(monitorState >= OTNN_MONITOR_WARNING)
g_probationGoodSamples = 0UL;
}
if(!finalizeProbationIfReady(window)) return false;
if(!maybeStartSimplification(window, monitorState)) return false;
if(!processAutonomyAction(window)) return false;
if(g_retryCooldown > 0UL) --g_retryCooldown;
if((g_state.tickLo % END_TELEMETRY_PERIOD) == 0UL)
logTelemetry(sampleError);
if((g_state.tickLo - g_lastStateSaveTickLo) >= END_STATE_SAVE_PERIOD)
{
if(!saveEnduranceState()) return false;
}
if(g_logFile != 0 && (g_state.tickLo - g_lastLogSyncTickLo) >= END_LOG_SYNC_PERIOD)
{
if(!file.fsync(g_logFile)) return false;
g_lastLogSyncTickLo = g_state.tickLo;
}
tickAdvance();
return true;
}
static void cleanStop()
{
otNNTrainingProgress p;
if(g_stopped) return;
g_stopped = 1;
memset(&p, 0, sizeof(p));
g_trainingSession.progress(p);
if(p.state == OTNN_TRAINING_RUNNING)
{
g_trainingSession.pause();
if(g_trainingSession.saveCheckpoint(END_TRAINING_PREFIX))
{
++g_checkpointsTotal;
logSimple("STOP", "training paused and checkpoint committed", 1);
}
}
if(g_controller.catalogDirty())
{
if(commitLifecycle("clean-stop")) g_controller.markCatalogCommitted();
}
saveEnduranceState();
logPrefix("SESSION");
file.fprintf(g_logFile,
"STOP clean promotions=%lu rollbacks=%lu rejections=%lu checkpoints=%lu archFailures=%lu nextStage=%lu resourceCap=%lu saturated=%lu attemptedMask=0x%03lX outcomeBits=0x%05lX simplify[mode=%lu stable=%lu activeAge=%lu sinceAttempt=%lu attempts=%lu promotions=%lu rejections=%lu rollbacks=%lu] heap=%lu logBytes=%lu",
g_promotionsTotal, g_rollbacksTotal, g_rejectionsTotal,
g_checkpointsTotal, g_state.architectureFailures,
g_state.architectureNextStage, g_state.architectureParameterCeiling,
g_state.architectureSaturated, g_state.architectureAttemptedMask,
g_state.architectureOutcomeBits,
g_state.simplificationLifecycleMode,
g_state.simplificationStableSamples,
g_state.simplificationActiveAgeSamples,
g_state.simplificationSamplesSinceAttempt,
g_state.simplificationAttempts,
g_state.simplificationPromotions,
g_state.simplificationRejections,
g_state.simplificationRollbacks,
(unsigned long)_memFree(), file.fsize(END_LOG_FILE));
logEnd(1);
closeEnduranceLog();
printf("\nEndurance stopped cleanly by ESC.\n");
printf("Lifecycle/catalog/state/checkpoints flushed to SD.\n");
}
/* ------------------------------------------------------------------------- */
/* otStudio entry points */
/* ------------------------------------------------------------------------- */
void setup()
{
UartEnableSignals(UART0);
UartSetBaud(UART0, 115200);
_initMalloc();
_initFastMalloc();
setStdout(4096, UART0);
if(!file.init())
{
printf("SD not found! System halted.\n");
IDLE;
}
file.setStdout(printf);
if(!initializeEndurance())
{
printf("Endurance initialization FAILED. System halted.\n");
if(g_logFile != 0) logSimple("FATAL", "initialization failed", 1);
closeEnduranceLog();
IDLE;
}
}
void loop()
{
if(g_stopped)
{
IDLE;
return;
}
if(stopRequested())
{
cleanStop();
return;
}
if(!enduranceStep())
{
logSimple("FATAL", "enduranceStep failed; stopping to preserve evidence", 1);
printf("FATAL: enduranceStep failed. Evidence flushed to SD.\n");
cleanStop();
return;
}
}
#endif