Source code for zisk/state-machines/binary/src/binary.rs

 1//! The `BinarySM` module implements the Binary State Machine,
 2//! coordinating sub-state machines to handle various binary operations seamlessly.
 3//!
 4//! Key components of this module include:
 5//! - The `BinarySM` struct, encapsulating the basic and extension state machines along with their
 6//!   table counterparts.
 7//! - `ComponentBuilder` trait implementations for creating counters, planners, and input collectors
 8//!   specific to binary operations.
 9
10use std::sync::Arc;
11
12use crate::{
13    BinaryAddInstance, BinaryAddSM, BinaryBasicInstance, BinaryBasicSM, BinaryCounter,
14    BinaryExtensionInstance, BinaryExtensionSM, BinaryPlanner,
15};
16use fields::PrimeField64;
17use pil_std_lib::Std;
18use zisk_common::{BusDeviceMetrics, ComponentBuilder, Instance, InstanceCtx, Planner};
19use zisk_pil::{BinaryAddTrace, BinaryExtensionTrace, BinaryTrace};
20
21/// The `BinarySM` struct represents the Binary State Machine,
22/// managing basic, extension and specific add binary operations.

23#[allow(dead_code)]
24pub struct BinarySM<F: PrimeField64> {
25    /// Binary Basic state machine
26    binary_basic_sm: Arc<BinaryBasicSM<F>>,
27
28    /// Binary Extension state machine
29    binary_extension_sm: Arc<BinaryExtensionSM<F>>,
30
31    /// Binary Add state machine (optimal only for addition)
32    binary_add_sm: Arc<BinaryAddSM<F>>,

33}

34
35impl<F: PrimeField64> BinarySM<F> {
36    /// Creates a new instance of the `BinarySM` state machine.
37    ///
38    /// # Arguments
39    /// * `std` - PIL2 standard library utilities.
40    ///
41    /// # Returns

42    /// An `Arc`-wrapped instance of `BinarySM`.
43    pub fn new(std: Arc<Std<F>>) -> Arc<Self> {
44        let binary_basic_sm = BinaryBasicSM::new(std.clone());
45
46        let binary_extension_sm = BinaryExtensionSM::new(std.clone());
47
48        let binary_add_sm = BinaryAddSM::new(std);
49
50        Arc::new(Self { binary_basic_sm, binary_extension_sm, binary_add_sm })

51    }

52
53    pub fn build_binary_counter(&self) -> BinaryCounter {
54        BinaryCounter::new()

55    }

56}

57
58impl<F: PrimeField64> ComponentBuilder<F> for BinarySM<F> {
59    /// Builds and returns a new counter for monitoring binary operations.
60    ///
61    /// # Returns
62    /// A boxed implementation of `RegularCounters` configured for binary and extension binary
63    /// operations.
64    fn build_counter(&self) -> Option<Box<dyn BusDeviceMetrics>> {
65        Some(Box::new(BinaryCounter::new()))
66    }
67
68    /// Builds a planner to plan binary-related instances.
69    ///
70    /// # Returns
71    /// A boxed implementation of `RegularPlanner`.
72    fn build_planner(&self) -> Box<dyn Planner> {
73        Box::new(BinaryPlanner::<F>::new())
74    }
75
76    /// Builds an instance for binary operations.
77    ///
78    /// # Arguments
79    /// * `ictx` - The instance context.
80    ///
81    /// # Returns
82    /// A boxed implementation of `Instance` for binary operations.
83    fn build_instance(&self, ictx: InstanceCtx) -> Box<dyn Instance<F>> {
84        match ictx.plan.air_id {
85            BinaryTrace::<F>::AIR_ID => {
86                Box::new(BinaryBasicInstance::new(self.binary_basic_sm.clone(), ictx))
87            }
88            BinaryExtensionTrace::<F>::AIR_ID => {
89                Box::new(BinaryExtensionInstance::new(self.binary_extension_sm.clone(), ictx))
90            }
91            BinaryAddTrace::<F>::AIR_ID => {
92                Box::new(BinaryAddInstance::new(self.binary_add_sm.clone(), ictx))
93            }
94            _ => panic!("BinarySM::get_instance() Unsupported air_id: {:?}", ictx.plan.air_id),
95        }
96    }

97}