Multi-batch splitting

Author: robknight

examples/main_pod_points.rs

@@ -88,7 +88,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         game_pk = game_pk,
     );
     println!("# custom predicate batch:{}", input);
-    let batch = parse(&input, &params, &[])?.custom_batch;
+    let batch = parse(&input, &params, &[])?
+        .first_batch()
+        .expect("Expected batch")
+        .clone();
     let points_pred = batch.predicate_ref_by_name("points").unwrap();
     let over_9000_pred = batch.predicate_ref_by_name("over_9000").unwrap();
 

src/backends/plonky2/mainpod/mod.rs

@@ -1179,7 +1179,9 @@ pub mod tests {
             &[],
         )
         .unwrap()
-        .custom_batch;
+        .first_batch()
+        .unwrap()
+        .clone();
         let mut builder = MainPodBuilder::new(&params, &DEFAULT_VD_SET);
         let cpr = CustomPredicateRef { batch, index: 0 };
         let eq_st = builder.priv_op(frontend::Operation::eq(1, 1)).unwrap();

src/examples/custom.rs

@@ -32,7 +32,11 @@ pub fn eth_dos_batch(params: &Params) -> Result<Arc<CustomPredicateBatch>> {
             eth_dos_ind(src, dst, distance)
         )
         "#;
-    let batch = parse(input, params, &[]).expect("lang parse").custom_batch;
+    let batch = parse(input, params, &[])
+        .expect("lang parse")
+        .first_batch()
+        .expect("Expected batch")
+        .clone();
     println!("a.0. {}", batch.predicates[0]);
     println!("a.1. {}", batch.predicates[1]);
     println!("a.2. {}", batch.predicates[2]);

src/frontend/mod.rs

@@ -1378,7 +1378,11 @@ pub mod tests {
             Equal(b, 5)
         )
         "#;
-        let batch = parse(input, &params, &[]).unwrap().custom_batch;
+        let batch = parse(input, &params, &[])
+            .unwrap()
+            .first_batch()
+            .unwrap()
+            .clone();
         let pred_test = batch.predicate_ref_by_name("Test").unwrap();
 
         // Try to build with wrong type in 1st arg

src/lang/error.rs

@@ -22,6 +22,9 @@ pub enum LangError {
 
     #[error("Lowering error: {0}")]
     Lowering(Box<LoweringError>),
+
+    #[error("Batching error: {0}")]
+    Batching(Box<BatchingError>),
 }
 
 /// Validation errors from frontend AST validation
@@ -90,14 +93,6 @@ pub enum ValidationError {
 /// Lowering errors from frontend AST lowering to middleware
 #[derive(Debug, thiserror::Error)]
 pub enum LoweringError {
-    #[error("Too many custom predicates in batch '{batch_name}': {count} exceeds limit of {max}{}", if *.original_count != *.count { format!(" (started with {} predicates before automatic splitting)", original_count) } else { String::new() })]
-    TooManyPredicates {
-        batch_name: String,
-        count: usize,
-        max: usize,
-        original_count: usize,
-    },
-
     #[error("Too many statements in predicate '{predicate}': {count} exceeds limit of {max}")]
     TooManyStatements {
         predicate: String,
@@ -127,6 +122,9 @@ pub enum LoweringError {
     #[error("Splitting error: {0}")]
     Splitting(#[from] SplittingError),
 
+    #[error("Batching error: {0}")]
+    Batching(#[from] BatchingError),
+
     #[error("Cannot lower document with validation errors")]
     ValidationErrors,
 }
@@ -235,6 +233,21 @@ fn format_public_args_at_split_error(
     msg
 }
 
+/// Batching errors from multi-batch packing
+#[derive(Debug, thiserror::Error)]
+pub enum BatchingError {
+    #[error("Forward cross-batch reference: predicate '{caller}' (batch {caller_batch}) calls '{callee}' (batch {callee_batch}). Move '{callee}' earlier or '{caller}' later.")]
+    ForwardCrossBatchReference {
+        caller: String,
+        caller_batch: usize,
+        callee: String,
+        callee_batch: usize,
+    },
+
+    #[error("Internal batching error: {message}")]
+    Internal { message: String },
+}
+
 /// Splitting errors from predicate splitting
 #[derive(Debug, thiserror::Error)]
 pub enum SplittingError {
@@ -271,13 +284,6 @@ pub enum SplittingError {
         max_allowed: usize,
         suggestion: Option<Box<RefactorSuggestion>>,
     },
-
-    #[error("Too many predicates in chain for '{predicate}': {count} exceeds batch limit of {max_allowed}")]
-    TooManyPredicatesInChain {
-        predicate: String,
-        count: usize,
-        max_allowed: usize,
-    },
 }
 
 impl From<ParseError> for LangError {
@@ -303,3 +309,9 @@ impl From<LoweringError> for LangError {
         LangError::Lowering(Box::new(err))
     }
 }
+
+impl From<BatchingError> for LangError {
+    fn from(err: BatchingError) -> Self {
+        LangError::Batching(Box::new(err))
+    }
+}