S425 · S212 consumption reconciliation

#![allow(unexpected_cfgs)]

//! S425 reconciliation of S424 continuation with the real S212 service result.
//!
//! A queued S187 continuation is not considered downstream-published until the
//! same CPU1 IRQ observes S212 consume its tuple and publish the S211 request.
//! Idle preserves S424; an unbound S212 publication fails closed. S210 remains
//! a separate next gate.

use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s424_continuation_receipt_publication::{
    G8lS424ContinuationReceipt, G8lS424ContinuationReceiptError,
    G8lS424ContinuationReceiptState, S424_DIRECT_SCHEDULER_ACCESS_SITES,
    S424_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES, S424_SOURCE_AUDIT_UNITS,
    S424_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES, S424_UNROUTED_DIRECT_ACCESS_SITES,
};

pub const S425_SOURCE_AUDIT_UNITS: usize = S424_SOURCE_AUDIT_UNITS;
pub const S425_DIRECT_SCHEDULER_ACCESS_SITES: usize = S424_DIRECT_SCHEDULER_ACCESS_SITES;
pub const S425_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES: usize =
    S424_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES;
pub const S425_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES: usize =
    S424_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES;
pub const S425_UNROUTED_DIRECT_ACCESS_SITES: usize = S424_UNROUTED_DIRECT_ACCESS_SITES;
pub const S425_S212_COMPLETION_SLOT_CAPACITY: usize = 1;
pub const S425_PRODUCTION_RECONCILIATION_CALLSITES: usize = 1;
pub const S425_S212_CONSUMPTION_RECONCILIATION_COMPLETE: bool = true;
pub const S425_S210_COMPLETION_RECONCILIATION_COMPLETE: bool = false;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS425S212Completion {
    pub attempt_id: u64,
    pub provider_request_id: u64,
    pub exclusive_token: u64,
    pub s212_tuple_consumed: bool,
    pub s211_request_published: bool,
    pub s210_completed: bool,
    pub runtime_observed: bool,
}

#[derive(Debug)]
pub struct G8lS425S212CompletionState {
    pending: Option<G8lS425S212Completion>,
}

impl G8lS425S212CompletionState {
    pub const fn new() -> Self {
        Self { pending: None }
    }
    pub const fn pending(&self) -> bool {
        self.pending.is_some()
    }
    pub fn pending_completion(
        &self,
        caller_cpu: usize,
    ) -> Result<Option<G8lS425S212Completion>, G8lS425S212ConsumptionReconciliationError> {
        if caller_cpu != 1 {
            return Err(G8lS425S212ConsumptionReconciliationError::WrongCpu);
        }
        Ok(self.pending)
    }
    pub(crate) fn publish(
        &mut self,
        completion: G8lS425S212Completion,
    ) -> Result<(), G8lS425S212ConsumptionReconciliationError> {
        if self.pending.is_some() {
            return Err(G8lS425S212ConsumptionReconciliationError::CompletionSlotOccupied);
        }
        self.pending = Some(completion);
        Ok(())
    }
    pub fn take(
        &mut self,
        caller_cpu: usize,
    ) -> Result<Option<G8lS425S212Completion>, G8lS425S212ConsumptionReconciliationError> {
        if caller_cpu != 1 {
            return Err(G8lS425S212ConsumptionReconciliationError::WrongCpu);
        }
        Ok(self.pending.take())
    }
}

impl Default for G8lS425S212CompletionState {
    fn default() -> Self {
        Self::new()
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS425S212ConsumptionReconciliationOutcome {
    Idle,
    AwaitingS212Publication,
    CompletionPublished(G8lS425S212Completion),
    CompletionPending(G8lS425S212Completion),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS425S212ConsumptionReconciliationError {
    WrongCpu,
    S424(G8lS424ContinuationReceiptError),
    ReceiptBindingDrift,
    UnboundS212Publication,
    ReceiptDisappeared,
    ReceiptDrift,
    CompletionSlotOccupied,
}

fn completion_from_receipt(
    receipt: G8lS424ContinuationReceipt,
) -> Result<G8lS425S212Completion, G8lS425S212ConsumptionReconciliationError> {
    if receipt.attempt_id == 0
        || receipt.provider_request_id == 0
        || receipt.exclusive_token == 0
        || !receipt.s421_envelope_consumed
        || !receipt.s223_to_s212_chain_returned
        || receipt.is_authority
        || receipt.runtime_observed
    {
        return Err(G8lS425S212ConsumptionReconciliationError::ReceiptBindingDrift);
    }
    Ok(G8lS425S212Completion {
        attempt_id: receipt.attempt_id,
        provider_request_id: receipt.provider_request_id,
        exclusive_token: receipt.exclusive_token,
        s212_tuple_consumed: true,
        s211_request_published: true,
        s210_completed: false,
        runtime_observed: false,
    })
}

pub fn service_s425_model_s212_consumption_reconciliation(
    receipts: &mut G8lS424ContinuationReceiptState,
    completions: &mut G8lS425S212CompletionState,
    caller_cpu: usize,
    s212_published: bool,
) -> Result<G8lS425S212ConsumptionReconciliationOutcome, G8lS425S212ConsumptionReconciliationError>
{
    if caller_cpu != 1 {
        return Err(G8lS425S212ConsumptionReconciliationError::WrongCpu);
    }
    if let Some(existing) = completions.pending_completion(caller_cpu)? {
        return Ok(G8lS425S212ConsumptionReconciliationOutcome::CompletionPending(existing));
    }
    let receipt = receipts
        .pending_receipt(caller_cpu)
        .map_err(G8lS425S212ConsumptionReconciliationError::S424)?;
    if !s212_published {
        return Ok(if receipt.is_some() {
            G8lS425S212ConsumptionReconciliationOutcome::AwaitingS212Publication
        } else {
            G8lS425S212ConsumptionReconciliationOutcome::Idle
        });
    }
    let receipt =
        receipt.ok_or(G8lS425S212ConsumptionReconciliationError::UnboundS212Publication)?;
    let completion = completion_from_receipt(receipt)?;
    let taken = receipts
        .take(caller_cpu)
        .map_err(G8lS425S212ConsumptionReconciliationError::S424)?
        .ok_or(G8lS425S212ConsumptionReconciliationError::ReceiptDisappeared)?;
    if taken != receipt {
        return Err(G8lS425S212ConsumptionReconciliationError::ReceiptDrift);
    }
    completions.publish(completion)?;
    Ok(G8lS425S212ConsumptionReconciliationOutcome::CompletionPublished(completion))
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
static S425_PRODUCTION_COMPLETIONS: spin::Mutex<G8lS425S212CompletionState> =
    spin::Mutex::new(G8lS425S212CompletionState::new());

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn service_s425_s212_consumption_reconciliation_on_cpu1(
    outcome: crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_current_task_runtime_owner_s197_tuple::G8lRuntimeOwnerS197TupleServiceOutcome,
) -> Result<G8lS425S212ConsumptionReconciliationOutcome, G8lS425S212ConsumptionReconciliationError>
{
    use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_current_task_runtime_owner_s197_tuple::G8lRuntimeOwnerS197TupleServiceOutcome;
    if let Some(existing) = S425_PRODUCTION_COMPLETIONS.lock().pending_completion(1)? {
        return Ok(G8lS425S212ConsumptionReconciliationOutcome::CompletionPending(existing));
    }
    let receipt = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s424_continuation_receipt_publication::inspect_s424_continuation_receipt_on_cpu1()
        .map_err(G8lS425S212ConsumptionReconciliationError::S424)?;
    if outcome != G8lRuntimeOwnerS197TupleServiceOutcome::Published {
        return Ok(if receipt.is_some() {
            G8lS425S212ConsumptionReconciliationOutcome::AwaitingS212Publication
        } else {
            G8lS425S212ConsumptionReconciliationOutcome::Idle
        });
    }
    let receipt =
        receipt.ok_or(G8lS425S212ConsumptionReconciliationError::UnboundS212Publication)?;
    let completion = completion_from_receipt(receipt)?;
    let taken = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s424_continuation_receipt_publication::take_s424_continuation_receipt_on_cpu1()
        .map_err(G8lS425S212ConsumptionReconciliationError::S424)?
        .ok_or(G8lS425S212ConsumptionReconciliationError::ReceiptDisappeared)?;
    if taken != receipt {
        return Err(G8lS425S212ConsumptionReconciliationError::ReceiptDrift);
    }
    S425_PRODUCTION_COMPLETIONS.lock().publish(completion)?;
    Ok(G8lS425S212ConsumptionReconciliationOutcome::CompletionPublished(completion))
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn inspect_s425_s212_completion_on_cpu1(
) -> Result<Option<G8lS425S212Completion>, G8lS425S212ConsumptionReconciliationError> {
    S425_PRODUCTION_COMPLETIONS.lock().pending_completion(1)
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn take_s425_s212_completion_on_cpu1(
) -> Result<Option<G8lS425S212Completion>, G8lS425S212ConsumptionReconciliationError> {
    S425_PRODUCTION_COMPLETIONS.lock().take(1)
}

use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s424_continuation_receipt_publication::{service_s424_model_continuation_receipt_publication, G8lS424ContinuationReceiptState};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s425_s212_consumption_reconciliation::*;

fn receipt() -> G8lS424ContinuationReceiptState {
    let mut state = G8lS424ContinuationReceiptState::new();
    service_s424_model_continuation_receipt_publication(&mut state, 1, 7, 8, 9, None, true)
        .unwrap();
    state
}

#[test]
fn constants_define_one_s212_reconciliation_slot() {
    assert_eq!(S425_S212_COMPLETION_SLOT_CAPACITY, 1);
    assert_eq!(S425_PRODUCTION_RECONCILIATION_CALLSITES, 1);
    assert!(S425_S212_CONSUMPTION_RECONCILIATION_COMPLETE);
    assert!(!S425_S210_COMPLETION_RECONCILIATION_COMPLETE);
}

#[test]
fn exact_s424_receipt_and_s212_publish_create_completion() {
    let mut receipt = receipt();
    let mut completions = G8lS425S212CompletionState::new();
    let outcome =
        service_s425_model_s212_consumption_reconciliation(&mut receipt, &mut completions, 1, true)
            .unwrap();
    let G8lS425S212ConsumptionReconciliationOutcome::CompletionPublished(done) = outcome else {
        panic!("completion")
    };
    assert_eq!(
        (
            done.attempt_id,
            done.provider_request_id,
            done.exclusive_token
        ),
        (7, 8, 9)
    );
    assert!(done.s212_tuple_consumed && done.s211_request_published);
    assert!(!done.s210_completed && !done.runtime_observed);
    assert!(!receipt.pending() && completions.pending());
}

#[test]
fn idle_s212_preserves_s424_receipt() {
    let mut receipt = receipt();
    let mut completions = G8lS425S212CompletionState::new();
    assert_eq!(
        service_s425_model_s212_consumption_reconciliation(
            &mut receipt,
            &mut completions,
            1,
            false
        )
        .unwrap(),
        G8lS425S212ConsumptionReconciliationOutcome::AwaitingS212Publication
    );
    assert!(receipt.pending() && !completions.pending());
}

#[test]
fn s212_publish_without_s424_receipt_fails_closed() {
    let mut receipt = G8lS424ContinuationReceiptState::new();
    let mut completions = G8lS425S212CompletionState::new();
    assert_eq!(
        service_s425_model_s212_consumption_reconciliation(&mut receipt, &mut completions, 1, true),
        Err(G8lS425S212ConsumptionReconciliationError::UnboundS212Publication)
    );
}

#[test]
fn occupied_completion_preserves_next_receipt() {
    let mut first = receipt();
    let mut completions = G8lS425S212CompletionState::new();
    service_s425_model_s212_consumption_reconciliation(&mut first, &mut completions, 1, true)
        .unwrap();
    let pending = completions.pending_completion(1).unwrap().unwrap();
    let mut next = receipt();
    assert_eq!(
        service_s425_model_s212_consumption_reconciliation(&mut next, &mut completions, 1, true)
            .unwrap(),
        G8lS425S212ConsumptionReconciliationOutcome::CompletionPending(pending)
    );
    assert!(next.pending());
}

#[test]
fn production_inspects_s424_before_take_and_maps_exact_s212_outcome() {
    let source = include_str!("../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s425_s212_consumption_reconciliation.rs");
    let start = source
        .find("service_s425_s212_consumption_reconciliation_on_cpu1")
        .unwrap();
    let body = &source[start..];
    let inspect = body
        .find("inspect_s424_continuation_receipt_on_cpu1")
        .unwrap();
    let published = body
        .find("G8lRuntimeOwnerS197TupleServiceOutcome::Published")
        .unwrap();
    let take = body.find("take_s424_continuation_receipt_on_cpu1").unwrap();
    assert!(inspect < published && published < take);
}

#[test]
fn timer_orders_s212_then_s425_then_s210() {
    let source = include_str!("../../kernel/src/arch/aarch64/exceptions.rs");
    let s212 = source
        .find("service_runtime_owner_s197_tuple_from_current_scheduler_task")
        .unwrap();
    let s425 = source
        .find("service_s425_s212_consumption_reconciliation_on_cpu1")
        .unwrap();
    let s210 = source
        .find("service_runtime_owned_current_task_owner_invocation")
        .unwrap();
    assert!(s212 < s425 && s425 < s210);
    let name = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s425_s212_consumption_reconciliation";
    assert!(include_str!("../../kernel/src/main.rs").contains(&format!("mod {name};")));
    assert!(include_str!("../src/lib.rs").contains(&format!("pub mod {name};")));
}

  {
    id: "g8l-s425-s212-consumption-reconciliation-partial",
    sequence: 425,
    slug: "s212_consumption_reconciliation",
    title: "S212 consumption reconciliation",
    focusedTests: 7,
    sourceBytes: 8973,
    sourceSha256:
      "d38f5b5e18b890e7c38a50b6db59bfd5557cccb9200036f63ea5e46164c3df85",
    testBytes: 4802,
    testSha256:
      "f5b2fb08c032fae5199887c780d819f61209c9205e36cb82f734458314958347",
    acceptance:
      "S424 receipt, continuation'ın S212 ingress tüketimine ulaştığını exact-once reconciliation sonucu ve capacity-one completion ile sabitler.",
    retainedBoundary:
      "S210 terminal completion reconciliation S426'ya ayrılmıştır.",
  },