Merge main into dev v2.12.0 (#7951)

Author: orizi

Cargo.lock

@@ -13,6 +13,7 @@ cairo-lang-compiler = { path = "../../cairo-lang-compiler", version = "~2.12.0-r
 cairo-lang-executable = { path = "../../cairo-lang-executable", version = "~2.12.0-rc.1" }
 cairo-lang-execute-utils = { path = "../../cairo-lang-execute-utils", version = "~2.12.0-rc.1" }
 cairo-lang-runner = { path = "../../cairo-lang-runner", version = "~2.12.0-rc.1" }
+cairo-lang-sierra-generator = { path = "../../cairo-lang-sierra-generator", version = "~2.12.0-rc.1" }
 cairo-vm = { workspace = true, features = ["clap"] }
 clap.workspace = true
 num-bigint.workspace = true

crates/bin/cairo-execute/Cargo.toml

@@ -1,15 +1,19 @@
 use std::io::{self, Write};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use anyhow::Context;
 use bincode::enc::write::Writer;
 use cairo_lang_compiler::diagnostics::DiagnosticsReporter;
-use cairo_lang_compiler::project::check_compiler_path;
-use cairo_lang_executable::compile::{ExecutableConfig, compile_executable};
+use cairo_lang_compiler::project::{check_compiler_path, setup_project};
+use cairo_lang_executable::compile::{
+    CompileExecutableResult, ExecutableConfig, compile_executable_in_prepared_db, prepare_db,
+};
 use cairo_lang_executable::executable::Executable;
 use cairo_lang_execute_utils::{program_and_hints_from_executable, user_args_from_flags};
 use cairo_lang_runner::casm_run::format_for_panic;
+use cairo_lang_runner::profiling::{ProfilingInfo, ProfilingInfoProcessor};
 use cairo_lang_runner::{Arg, CairoHintProcessor};
+use cairo_lang_sierra_generator::replace_ids::replace_sierra_ids_in_program;
 use cairo_vm::cairo_run;
 use cairo_vm::cairo_run::{CairoRunConfig, cairo_run_program};
 use cairo_vm::types::layout::CairoLayoutParams;
@@ -38,13 +42,18 @@ struct Args {
     /// In `--build-only` this would be the executable artifact.
     /// In bootloader mode it will be the resulting cairo PIE file.
     /// In standalone mode this parameter is disallowed.
-    #[arg(long, required_unless_present("standalone"))]
+    #[arg(long, required_unless_present_any(["standalone", "profile"]))]
     output_path: Option<PathBuf>,
 
     /// Whether to only run a prebuilt executable.
     #[arg(long, default_value_t = false, conflicts_with = "build_only")]
     prebuilt: bool,
 
+    /// The path to save the profiling result.
+    /// Currently does not work with prebuilt executables as it requires additional debug info.
+    #[arg(long, conflicts_with_all = ["prebuilt", "standalone"])]
+    profile: bool,
+
     #[command(flatten)]
     build: BuildArgs,
 
@@ -165,30 +174,51 @@ struct ProofOutputArgs {
 fn main() -> anyhow::Result<()> {
     let args = Args::parse();
 
-    let executable = {
+    let (opt_debug_data, executable) = {
         if args.prebuilt {
-            serde_json::from_reader(std::fs::File::open(&args.input_path)?)
-                .with_context(|| "Failed reading prebuilt executable.")?
+            let executable: Executable =
+                serde_json::from_reader(std::fs::File::open(&args.input_path)?)
+                    .with_context(|| "Failed reading prebuilt executable.")?;
+            (None, executable)
         } else {
             // Check if args.path is a file or a directory.
             check_compiler_path(args.build.single_file, &args.input_path)?;
-            let mut reporter = DiagnosticsReporter::stderr();
+
+            let mut diagnostics_reporter = DiagnosticsReporter::stderr();
             if args.build.allow_warnings {
-                reporter = reporter.allow_warnings();
+                diagnostics_reporter = diagnostics_reporter.allow_warnings();
             }
             if args.build.ignore_warnings {
-                reporter = reporter.ignore_all_warnings();
+                diagnostics_reporter = diagnostics_reporter.ignore_all_warnings();
             }
-
-            Executable::new(compile_executable(
-                &args.input_path,
-                args.build.executable.as_deref(),
-                reporter,
-                ExecutableConfig {
-                    allow_syscalls: args.build.allow_syscalls,
-                    unsafe_panic: args.build.unsafe_panic,
-                },
-            )?)
+            let config = ExecutableConfig {
+                allow_syscalls: args.build.allow_syscalls,
+                unsafe_panic: args.build.unsafe_panic,
+            };
+
+            let mut db = prepare_db(&config)?;
+
+            let main_crate_ids = setup_project(&mut db, Path::new(&args.input_path))?;
+            let diagnostics_reporter = diagnostics_reporter.with_crates(&main_crate_ids);
+
+            let CompileExecutableResult { compiled_function, builder, debug_info } =
+                compile_executable_in_prepared_db(
+                    &db,
+                    args.build.executable.as_deref(),
+                    main_crate_ids,
+                    diagnostics_reporter,
+                    config,
+                )?;
+
+            let header_len = compiled_function
+                .wrapper
+                .header
+                .iter()
+                .map(|insn| insn.body.op_size())
+                .sum::<usize>();
+
+            let executable = Executable::new(compiled_function);
+            (Some((db, builder, debug_info, header_len)), executable)
         }
     };
 
@@ -223,8 +253,10 @@ fn main() -> anyhow::Result<()> {
         None => None,
     };
 
+    let trace_enabled = args.profile || args.run.proof_outputs.trace_file.is_some();
+
     let cairo_run_config = CairoRunConfig {
-        trace_enabled: args.run.proof_outputs.trace_file.is_some(),
+        trace_enabled,
         relocate_mem: args.run.proof_outputs.memory_file.is_some(),
         layout: args.run.layout,
         dynamic_layout_params,
@@ -291,6 +323,26 @@ fn main() -> anyhow::Result<()> {
             .write_zip_file(&file_name, true)?
     }
 
+    if args.profile {
+        let (db, builder, debug_info, header_len) =
+            opt_debug_data.expect("debug data should be available when profiling");
+
+        let trace = runner.relocated_trace.as_ref().with_context(|| "Trace not relocated.")?;
+        let entry_point_offset = trace.first().unwrap().pc;
+        // TODO(ilya): Compute the correct load offset for standalone mode.
+        let load_offset = entry_point_offset + header_len;
+        let info = ProfilingInfo::from_trace(&builder, load_offset, &Default::default(), trace);
+
+        let profiling_processor = ProfilingInfoProcessor::new(
+            Some(&db),
+            replace_sierra_ids_in_program(&db, builder.sierra_program()),
+            debug_info.statements_locations.get_statements_functions_map_for_tests(&db),
+            Default::default(),
+        );
+        let processed_profiling_info = profiling_processor.process_ex(&info, &Default::default());
+        println!("{processed_profiling_info}");
+    }
+
     Ok(())
 }
 

crates/bin/cairo-execute/src/main.rs

@@ -14,7 +14,9 @@ use cairo_lang_runnable_utils::builder::{
     CasmProgramWrapperInfo, EntryCodeConfig, RunnableBuilder,
 };
 use cairo_lang_sierra_generator::executables::find_executable_function_ids;
-use cairo_lang_sierra_generator::program_generator::SierraProgramWithDebug;
+use cairo_lang_sierra_generator::program_generator::{
+    SierraProgramDebugInfo, SierraProgramWithDebug,
+};
 use cairo_lang_sierra_to_casm::compiler::CairoProgram;
 use cairo_lang_utils::{Intern, write_comma_separated};
 use itertools::Itertools;
@@ -62,14 +64,21 @@ pub struct ExecutableConfig {
     pub unsafe_panic: bool,
 }
 
+/// Represents the output of compiling an executable.
+///
+/// Includes the `CompiledFunction` along with supplementary objects useful for profiling.
+pub struct CompileExecutableResult {
+    /// The compiled function.
+    pub compiled_function: CompiledFunction,
+    /// A runnable builder with the program corresponding to the compiled function.
+    pub builder: RunnableBuilder,
+    /// The debug info for the sierra program in the builder.
+    pub debug_info: SierraProgramDebugInfo,
+}
+
 /// Compile the function given by path.
 /// Errors if there is ambiguity.
-pub fn compile_executable(
-    path: &Path,
-    executable_path: Option<&str>,
-    diagnostics_reporter: DiagnosticsReporter<'_>,
-    config: ExecutableConfig,
-) -> Result<CompiledFunction> {
+pub fn prepare_db(config: &ExecutableConfig) -> Result<RootDatabase> {
     let mut builder = RootDatabase::builder();
     builder
         .skip_auto_withdraw_gas()
@@ -80,7 +89,18 @@ pub fn compile_executable(
         builder.with_unsafe_panic();
     }
 
-    let mut db = builder.build()?;
+    builder.build()
+}
+
+/// Compile the function given by path.
+/// Errors if there is ambiguity.
+pub fn compile_executable(
+    path: &Path,
+    executable_path: Option<&str>,
+    diagnostics_reporter: DiagnosticsReporter<'_>,
+    config: ExecutableConfig,
+) -> Result<CompileExecutableResult> {
+    let mut db = prepare_db(&config)?;
 
     let main_crate_ids = setup_project(&mut db, Path::new(&path))?;
     let diagnostics_reporter = diagnostics_reporter.with_crates(&main_crate_ids);
@@ -103,7 +123,7 @@ pub fn compile_executable_in_prepared_db(
     main_crate_ids: Vec<CrateId>,
     mut diagnostics_reporter: DiagnosticsReporter<'_>,
     config: ExecutableConfig,
-) -> Result<CompiledFunction> {
+) -> Result<CompileExecutableResult> {
     let context = DbWarmupContext::new();
     context.ensure_diagnostics(db, &mut diagnostics_reporter)?;
 
@@ -183,7 +203,7 @@ pub fn compile_executable_function_in_prepared_db(
     executable: ConcreteFunctionWithBodyId,
     config: ExecutableConfig,
     context: DbWarmupContext,
-) -> Result<CompiledFunction> {
+) -> Result<CompileExecutableResult> {
     let SierraProgramWithDebug { program: sierra_program, debug_info } = Arc::unwrap_or_clone(
         get_sierra_program_for_functions(db, vec![executable], context)
             .ok()
@@ -228,5 +248,6 @@ pub fn compile_executable_function_in_prepared_db(
     let allow_unsound = config.allow_syscalls;
     let wrapper = builder
         .create_wrapper_info(&executable_func, EntryCodeConfig::executable(allow_unsound))?;
-    Ok(CompiledFunction { program: builder.casm_program().clone(), wrapper })
+    let compiled_function = CompiledFunction { program: builder.casm_program().clone(), wrapper };
+    Ok(CompileExecutableResult { compiled_function, builder, debug_info })
 }

crates/cairo-lang-executable/src/compile.rs

@@ -79,7 +79,7 @@ impl TestFileRunner for CompileExecutableTestRunner {
             DiagnosticsReporter::stderr().with_crates(&[test_module.crate_id]),
             Default::default(),
         )
-        .map(|compiled| compiled.to_string())
+        .map(|compiled| compiled.compiled_function.to_string())
         .unwrap_or_else(|e| e.to_string());
         let error = verify_diagnostics_expectation(args, &semantic_diagnostics);
         TestRunnerResult {

crates/cairo-lang-executable/src/test.rs

@@ -110,44 +110,58 @@ error: Capture of mutable variables in a closure is not supported
 
 //! > ==========================================================================
 
-//! > invalidated capture immutable variable
+//! > Use of captured var.
 
 //! > test_runner_name
 test_borrow_check
 
 //! > function
 fn foo(a: S) {
-    |b: u32| {
-        let _ = a.a + b;
+    || {
+        use_s(a)
     };
+
+    // TODO(ilya): Consider adding automatic destructuring of the closure before the following line
     let _ = a.a;
 }
 
 //! > function_name
 foo
 
 //! > module_code
+#[derive(Drop)]
 struct S {
     a: u32,
 }
 
+extern fn use_s(s: S) nopanic;
+
 //! > semantic_diagnostics
 
 //! > lowering_diagnostics
+error: Variable was previously moved.
+ --> lib.cairo:13:13
+    let _ = a.a;
+            ^^^
+note: variable was previously used here:
+  --> lib.cairo:9:15
+        use_s(a)
+              ^
+note: Trait has no implementation in context: core::traits::Copy::<test::S>.
 
 //! > lowering
 Parameters: v0: test::S
 blk0 (root):
 Statements:
-  (v1: core::integer::u32) <- struct_destructure(v0{`a.a`})
-  (v2: {[email protected]:5:5: 5:13}) <- struct_construct(v1{`a.a`})
+  (v1: {[email protected]:8:5: 8:7}) <- struct_construct(v0{`a`})
+  (v2: core::integer::u32) <- struct_destructure(v0{`a.a`})
   (v3: ()) <- struct_construct()
 End:
   Return(v3)
 
 //! > ==========================================================================
 
-//! > capture use after invalidatian.
+//! > Use of captured mutable variable.
 
 //! > test_runner_name
 test_borrow_check
@@ -185,29 +199,37 @@ error: Capture of mutable variables in a closure is not supported
 test_borrow_check
 
 //! > function
-fn foo(mut a: Array<u32>) {
+fn foo(a: Array<u32>) {
     let f = |_b: u32| {
         let _ = a.len();
     };
-    a.append(0);
-    use_f(f)
+    // Since only a snapshot of `a` is capture, we can use it while it is captured.
+    use_value(a);
+
+    use_value(f);
 }
 
 //! > function_name
 foo
 
 //! > module_code
-extern fn use_f<T>(f: T) nopanic;
+extern fn use_value<T>(f: T) nopanic;
 
 //! > semantic_diagnostics
-error: Capture of mutable variables in a closure is not supported
- --> lib.cairo:4:17
-        let _ = a.len();
-                ^
 
 //! > lowering_diagnostics
 
 //! > lowering
+Parameters: v0: core::array::Array::<core::integer::u32>
+blk0 (root):
+Statements:
+  (v1: core::array::Array::<core::integer::u32>, v2: @core::array::Array::<core::integer::u32>) <- snapshot(v0{`a`})
+  (v3: {[email protected]:3:13: 3:22}) <- struct_construct(v2{`|_b: u32| { let _ = a.len(); }`})
+  () <- test::use_value::<core::array::Array::<core::integer::u32>>(v1{`a`})
+  () <- test::use_value::<{[email protected]:3:13: 3:22}>(v3{`f`})
+  (v4: ()) <- struct_construct()
+End:
+  Return(v4)
 
 //! > ==========================================================================