Added ability to control inlining level through optimization config. (#7401)

Author: orizi

crates/cairo-lang-lowering/src/inline/mod.rs

@@ -67,30 +67,35 @@ pub fn priv_should_inline(
     let config = db.function_declaration_inline_config(
         function_id.function_with_body_id(db).base_semantic_function(db),
     )?;
-
-    Ok(match db.optimization_config().inlining_strategy {
-        InliningStrategy::Default => match config {
-            InlineConfiguration::Never(_) => false,
-            InlineConfiguration::Should(_) => true,
-            InlineConfiguration::Always(_) => true,
-            InlineConfiguration::None => should_inline_lowered(db, function_id)?,
-        },
-        InliningStrategy::Avoid => matches!(config, InlineConfiguration::Always(_)),
+    Ok(match (db.optimization_config().inlining_strategy, config) {
+        (_, InlineConfiguration::Always(_)) => true,
+        (InliningStrategy::Avoid, _) | (_, InlineConfiguration::Never(_)) => false,
+        (_, InlineConfiguration::Should(_)) => true,
+        (InliningStrategy::Default, InlineConfiguration::None) => {
+            /// The default threshold for inlining small functions. Decided according to sample
+            /// contracts profiling.
+            const DEFAULT_INLINE_SMALL_FUNCTIONS_THRESHOLD: usize = 24;
+            should_inline_lowered(db, function_id, DEFAULT_INLINE_SMALL_FUNCTIONS_THRESHOLD)?
+        }
+        (InliningStrategy::InlineSmallFunctions(threshold), InlineConfiguration::None) => {
+            should_inline_lowered(db, function_id, threshold)?
+        }
     })
 }
 
 // A heuristic to decide if a function without an inline attribute should be inlined.
 fn should_inline_lowered(
     db: &dyn LoweringGroup,
     function_id: ConcreteFunctionWithBodyId,
+    inline_small_functions_threshold: usize,
 ) -> Maybe<bool> {
     let lowered = db.inlined_function_with_body_lowered(function_id)?;
     // The inline heuristics optimization flag only applies to non-trivial small functions.
     // Functions which contains only a call or a literal are always inlined.
 
     let weight_of_blocks = ApproxCasmInlineWeight::new(db, &lowered).lowered_weight(&lowered);
 
-    if weight_of_blocks < inline_small_functions_threshold(db).into_or_panic() {
+    if weight_of_blocks < inline_small_functions_threshold.into_or_panic() {
         return Ok(true);
     }
 
@@ -99,7 +104,7 @@ fn should_inline_lowered(
     // Functions which contains only a call or a literal are always inlined.
     let num_of_statements: usize =
         lowered.blocks.iter().map(|(_, block)| block.statements.len()).sum();
-    if num_of_statements < inline_small_functions_threshold(db) {
+    if num_of_statements < inline_small_functions_threshold {
         return Ok(true);
     }
 
@@ -369,9 +374,3 @@ pub fn apply_inlining(
     }
     Ok(())
 }
-
-/// Returns the threshold, in number of lowering statements, below which a function is marked as
-/// `should_inline`.
-fn inline_small_functions_threshold(db: &dyn LoweringGroup) -> usize {
-    db.optimization_config().inline_small_functions_threshold
-}

crates/cairo-lang-lowering/src/optimizations/config.rs

@@ -9,19 +9,11 @@ use crate::db::LoweringGroup;
 use crate::ids::{FunctionId, FunctionLongId};
 use crate::utils::InliningStrategy;
 
-/// The default threshold for inlining small functions. Decided according to sample contracts
-/// profiling.
-// TODO(Gil): Expose this as a configuration in the project toml.
-const DEFAULT_INLINE_SMALL_FUNCTIONS_THRESHOLD: usize = 24;
-
 /// A configuration struct that controls the behavior of the optimization passes.
 #[derive(Debug, Eq, PartialEq, Clone)]
 pub struct OptimizationConfig {
     /// A list of functions that can be moved during the reorder_statements optimization.
     pub moveable_functions: Vec<String>,
-    /// The size of functions (in lowering statements) below which they are marked as
-    /// `should_inline`.
-    pub inline_small_functions_threshold: usize,
     /// Determines whether inlining is disabled.
     pub inlining_strategy: InliningStrategy,
     /// Should const folding be skipped.
@@ -38,14 +30,6 @@ impl OptimizationConfig {
     pub fn with_minimal_movable_functions(self) -> Self {
         self.with_moveable_functions(vec!["felt252_sub".into()])
     }
-    /// Sets the threshold for inlining small functions.
-    pub fn with_inline_small_functions_threshold(
-        mut self,
-        inline_small_functions_threshold: usize,
-    ) -> Self {
-        self.inline_small_functions_threshold = inline_small_functions_threshold;
-        self
-    }
     /// Sets the `inlining_strategy` flag.
     pub fn with_inlining_strategy(mut self, inlining_strategy: InliningStrategy) -> Self {
         self.inlining_strategy = inlining_strategy;
@@ -62,7 +46,6 @@ impl Default for OptimizationConfig {
     fn default() -> Self {
         Self {
             moveable_functions: vec![],
-            inline_small_functions_threshold: DEFAULT_INLINE_SMALL_FUNCTIONS_THRESHOLD,
             inlining_strategy: InliningStrategy::Default,
             skip_const_folding: false,
         }

crates/cairo-lang-lowering/src/utils.rs

@@ -12,8 +12,14 @@ use crate::{
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
 pub enum InliningStrategy {
     /// Do not override inlining strategy.
+    ///
+    /// Note: equivalent to `InlineSmallFunctions(DEFAULT_INLINE_SMALL_FUNCTIONS_THRESHOLD)`.
     #[default]
     Default,
+    /// Should inline small functions up to the given weight.
+    ///
+    /// Note: the weight exact definition is subject to change.
+    InlineSmallFunctions(usize),
     /// Inline only in the case of an `inline(always)` annotation.
     Avoid,
 }