Merge branch 'remove-vec-alloc' into lean-vm-simple

Author: TomWambsgans

README.md

@@ -56,7 +56,7 @@ RUSTFLAGS='-C target-cpu=native' cargo run --release -- recursion --count 18
 ### XMSS aggregation
 
 ```console
-RUSTFLAGS='-C target-cpu=native' cargo run --release -- xmss --n-signatures 1200
+RUSTFLAGS='-C target-cpu=native' cargo run --release -- xmss --n-signatures 1250
 ```
 
 [Trivial encoding](docs/XMSS_trivial_encoding.pdf) (for now).

crates/lean_compiler/src/a_simplify_lang.rs

@@ -135,8 +135,6 @@ pub enum SimpleLine {
     HintMAlloc {
         var: Var,
         size: SimpleExpr,
-        vectorized: bool,
-        vectorized_len: SimpleExpr,
     },
     ConstMalloc {
         // always not vectorized
@@ -308,11 +306,8 @@ fn check_block_scoping(block: &[Line], ctx: &mut Context) {
             Line::MAlloc {
                 var,
                 size,
-                vectorized: _,
-                vectorized_len,
             } => {
                 check_expr_scoping(size, ctx);
-                check_expr_scoping(vectorized_len, ctx);
                 let last_scope = ctx.scopes.last_mut().unwrap();
                 assert!(
                     !last_scope.vars.contains(var),
@@ -808,17 +803,10 @@ fn simplify_lines(
                 assert!(in_a_loop, "Break statement outside of a loop");
                 res.push(SimpleLine::FunctionRet { return_data: vec![] });
             }
-            Line::MAlloc {
-                var,
-                size,
-                vectorized,
-                vectorized_len,
-            } => {
+            Line::MAlloc { var, size } => {
                 let simplified_size = simplify_expr(size, &mut res, counters, array_manager, const_malloc);
-                let simplified_vectorized_len =
-                    simplify_expr(vectorized_len, &mut res, counters, array_manager, const_malloc);
                 match simplified_size {
-                    SimpleExpr::Constant(const_size) if !*vectorized => {
+                    SimpleExpr::Constant(const_size) => {
                         let label = const_malloc.counter;
                         const_malloc.counter += 1;
                         const_malloc.map.insert(var.clone(), label);
@@ -832,8 +820,6 @@ fn simplify_lines(
                         res.push(SimpleLine::HintMAlloc {
                             var: var.clone(),
                             size: simplified_size,
-                            vectorized: *vectorized,
-                            vectorized_len: simplified_vectorized_len,
                         });
                     }
                 }
@@ -1537,16 +1523,10 @@ fn replace_vars_for_unroll(
                     replace_vars_for_unroll_in_expr(var, iterator, unroll_index, iterator_value, internal_vars);
                 }
             }
-            Line::MAlloc {
-                var,
-                size,
-                vectorized: _,
-                vectorized_len,
-            } => {
+            Line::MAlloc { var, size } => {
                 assert!(var != iterator, "Weird");
                 *var = format!("@unrolled_{unroll_index}_{iterator_value}_{var}");
                 replace_vars_for_unroll_in_expr(size, iterator, unroll_index, iterator_value, internal_vars);
-                replace_vars_for_unroll_in_expr(vectorized_len, iterator, unroll_index, iterator_value, internal_vars);
             }
             Line::DecomposeBits { var, to_decompose } => {
                 assert!(var != iterator, "Weird");
@@ -2170,17 +2150,8 @@ impl SimpleLine {
                 let content_str = content.iter().map(|c| format!("{c}")).collect::<Vec<_>>().join(", ");
                 format!("print({content_str})")
             }
-            Self::HintMAlloc {
-                var,
-                size,
-                vectorized,
-                vectorized_len,
-            } => {
-                if *vectorized {
-                    format!("{var} = malloc_vec({size}, {vectorized_len})")
-                } else {
-                    format!("{var} = malloc({size})")
-                }
+            Self::HintMAlloc { var, size } => {
+                format!("{var} = malloc({size})")
             }
             Self::ConstMalloc { var, size, label: _ } => {
                 format!("{var} = malloc({size})")

crates/lean_compiler/src/b_compile_intermediate.rs

@@ -486,8 +486,6 @@ fn compile_lines(
             SimpleLine::HintMAlloc {
                 var,
                 size,
-                vectorized,
-                vectorized_len,
             } => {
                 if !compiler.is_in_scope(var) {
                     let current_scope_layout = compiler.stack_frame_layout.scopes.last_mut().unwrap();
@@ -499,8 +497,6 @@ fn compile_lines(
                 instructions.push(IntermediateInstruction::RequestMemory {
                     offset: compiler.get_offset(&var.clone().into()),
                     size: IntermediateValue::from_simple_expr(size, compiler),
-                    vectorized: *vectorized,
-                    vectorized_len: IntermediateValue::from_simple_expr(vectorized_len, compiler),
                 });
             }
             SimpleLine::ConstMalloc { var, size, label } => {
@@ -620,8 +616,6 @@ fn setup_function_call(
         IntermediateInstruction::RequestMemory {
             offset: new_fp_pos.into(),
             size: ConstExpression::function_size(Label::function(func_name)).into(),
-            vectorized: false,
-            vectorized_len: IntermediateValue::Constant(ConstExpression::zero()),
         },
         IntermediateInstruction::Deref {
             shift_0: new_fp_pos.into(),

crates/lean_compiler/src/c_compile_final.rs

@@ -337,17 +337,12 @@ fn compile_block(
             IntermediateInstruction::RequestMemory {
                 offset,
                 size,
-                vectorized,
-                vectorized_len,
             } => {
                 let size = try_as_mem_or_constant(&size).unwrap();
-                let vectorized_len = try_as_constant(&vectorized_len, compiler).unwrap().to_usize();
                 let hint = Hint::RequestMemory {
                     function_name: function_name.clone(),
                     offset: eval_const_expression_usize(&offset, compiler),
-                    vectorized,
                     size,
-                    vectorized_len,
                 };
                 hints.entry(pc).or_default().push(hint);
             }

crates/lean_compiler/src/ir/instruction.rs

@@ -44,8 +44,6 @@ pub enum IntermediateInstruction {
     RequestMemory {
         offset: ConstExpression, // m[fp + offset] where the hint will be stored
         size: IntermediateValue, // the hint
-        vectorized: bool, // if true, will be (2^vectorized_len)-alligned, and the returned pointer will be "divied" by 2^vectorized_len
-        vectorized_len: IntermediateValue,
     },
     DecomposeBits {
         res_offset: usize, // m[fp + res_offset..fp + res_offset + 31 * len(to_decompose)] will contain the decomposed bits
@@ -171,14 +169,8 @@ impl Display for IntermediateInstruction {
             Self::RequestMemory {
                 offset,
                 size,
-                vectorized,
-                vectorized_len,
             } => {
-                if *vectorized {
-                    write!(f, "m[fp + {offset}] = request_memory_vec({size}, {vectorized_len})")
-                } else {
-                    write!(f, "m[fp + {offset}] = request_memory({size})")
-                }
+                write!(f, "m[fp + {offset}] = request_memory({size})")
             }
             Self::DecomposeBits {
                 res_offset,

crates/lean_compiler/src/lang.rs

@@ -359,8 +359,6 @@ pub enum Line {
     MAlloc {
         var: Var,
         size: Expression,
-        vectorized: bool,
-        vectorized_len: Expression,
     },
     DecomposeBits {
         var: Var, // a pointer to 31 * len(to_decompose) field elements, containing the bits of "to_decompose"
@@ -551,14 +549,8 @@ impl Line {
             Self::MAlloc {
                 var,
                 size,
-                vectorized,
-                vectorized_len,
             } => {
-                if *vectorized {
-                    format!("{var} = malloc_vec({size}, {vectorized_len})")
-                } else {
-                    format!("{var} = malloc({size})")
-                }
+                format!("{var} = malloc({size})")
             }
             Self::DecomposeBits { var, to_decompose } => {
                 format!(

crates/lean_compiler/src/lib.rs

@@ -30,21 +30,9 @@ pub fn compile_program(program: String) -> Bytecode {
     // compiled
 }
 
-pub fn compile_and_run(
-    program: String,
-    (public_input, private_input): (&[F], &[F]),
-    no_vec_runtime_memory: usize, // size of the "non-vectorized" runtime memory
-    profiler: bool,
-) {
+pub fn compile_and_run(program: String, (public_input, private_input): (&[F], &[F]), profiler: bool) {
     let bytecode = compile_program(program);
-    let summary = execute_bytecode(
-        &bytecode,
-        (public_input, private_input),
-        no_vec_runtime_memory,
-        profiler,
-        &vec![],
-    )
-    .summary;
+    let summary = execute_bytecode(&bytecode, (public_input, private_input), profiler, &vec![]).summary;
     println!("{summary}");
 }
 

crates/lean_compiler/src/parser/parsers/function.rs

@@ -10,7 +10,7 @@ use crate::{
         grammar::{ParsePair, Rule},
     },
 };
-use lean_vm::{ALL_TABLES, LOG_VECTOR_LEN, Table, TableT};
+use lean_vm::{ALL_TABLES, Table, TableT};
 
 /// Parser for complete function definitions.
 pub struct FunctionParser;
@@ -160,24 +160,6 @@ impl FunctionCallParser {
                 Ok(Line::MAlloc {
                     var: return_data[0].clone(),
                     size: args[0].clone(),
-                    vectorized: false,
-                    vectorized_len: Expression::zero(),
-                })
-            }
-            "malloc_vec" => {
-                let vectorized_len = if args.len() == 1 {
-                    Expression::scalar(LOG_VECTOR_LEN)
-                } else if args.len() == 2 {
-                    args[1].clone()
-                } else {
-                    return Err(SemanticError::new("Invalid malloc_vec call").into());
-                };
-
-                Ok(Line::MAlloc {
-                    var: return_data[0].clone(),
-                    size: args[0].clone(),
-                    vectorized: true,
-                    vectorized_len,
                 })
             }
             "print" => {