Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

fix(ssa): Check arrays used as a terminator argument in the RC tracker #7165

Merged
merged 13 commits into from
Jan 23, 2025

Conversation

vezenovm
Copy link
Contributor

@vezenovm vezenovm commented Jan 23, 2025

Description

Problem*

Resolves failures in AztecProtocol/aztec-packages#11294 from the preprocessing pass. #7163 is a bit too conservative with marking that we should keep the inc rcs on any parameters. Doing so happens to also fix the test case, but marking arrays passed to terminators is the more accurate fix for how the RC tracker should be looking at mutated arrays.

Summary*

We want to make sure we do not remove inc rcs on arrays that are potentially mutated elsewhere. To do so, we check whether an array was passed to a store instruction or a call. We used to only run DIE (which removes these RCs) at the end of the SSA optimizations where we were aggressively inlining.

Now that we are starting to process functions in isolation we triggered a bug as outlined here AztecProtocol/aztec-packages#11294 (comment). We need to account for whether an array is used in a terminator argument such as a return as that returned array may be mutated later.

Additional Context

Will need to add a new test making sure we do not remove an inc rc on an array type used in a terminator argument.

Documentation*

Check one:

  • No documentation needed.
  • Documentation included in this PR.
  • [For Experimental Features] Documentation to be submitted in a separate PR.

PR Checklist*

  • I have tested the changes locally.
  • I have formatted the changes with Prettier and/or cargo fmt on default settings.

@vezenovm vezenovm changed the title check references passed to a call in the rc tracker fix(ssa): check references passed to a call in the rc tracker Jan 23, 2025
@vezenovm vezenovm changed the title fix(ssa): check references passed to a call in the rc tracker fix(ssa): Check references containing arrays passed to a call in the rc tracker Jan 23, 2025
Copy link
Contributor

github-actions bot commented Jan 23, 2025

Changes to Brillig bytecode sizes

Generated at commit: bbeb28e6c00cf615ca7c0cd7f8ceaf861ed45296, compared to commit: 7b0411fa419248535ea23f80a4cb4621cf244fdb

🧾 Summary (10% most significant diffs)

Program Brillig opcodes (+/-) %
brillig_fns_as_values_inliner_min +199 ❌ +904.55%
brillig_fns_as_values_inliner_zero +148 ❌ +672.73%
trait_as_return_type_inliner_min +94 ❌ +427.27%
brillig_identity_function_inliner_min +85 ❌ +404.76%
struct_inliner_min +125 ❌ +390.63%
brillig_loop_size_regression_inliner_min +68 ❌ +309.09%
1327_concrete_in_generic_inliner_min +59 ❌ +178.79%
diamond_deps_0_inliner_min +30 ❌ +107.14%
array_to_slice_constant_length_inliner_min +20 ❌ +95.24%
array_len_inliner_min +84 ❌ +77.78%
fold_after_inlined_calls_inliner_min +27 ❌ +77.14%
trait_as_return_type_inliner_zero +14 ❌ +63.64%
missing_closure_env_inliner_zero +16 ❌ +61.54%
regression_4124_inliner_min +33 ❌ +60.00%
trait_impl_base_type_inliner_min +146 ❌ +58.40%
regression_7128_inliner_min +81 ❌ +55.48%
brillig_acir_as_brillig_inliner_min +61 ❌ +53.98%
closures_mut_ref_inliner_zero +17 ❌ +50.00%
brillig_not_inliner_min +18 ❌ +48.65%
derive_inliner_min +279 ❌ +47.77%
regression_6451_inliner_min +26 ❌ +44.83%
global_var_regression_simple_inliner_min +67 ❌ +40.12%

Full diff report 👇
Program Brillig opcodes (+/-) %
brillig_fns_as_values_inliner_min 221 (+199) +904.55%
brillig_fns_as_values_inliner_zero 170 (+148) +672.73%
trait_as_return_type_inliner_min 116 (+94) +427.27%
brillig_identity_function_inliner_min 106 (+85) +404.76%
struct_inliner_min 157 (+125) +390.63%
brillig_loop_size_regression_inliner_min 90 (+68) +309.09%
1327_concrete_in_generic_inliner_min 92 (+59) +178.79%
diamond_deps_0_inliner_min 58 (+30) +107.14%
array_to_slice_constant_length_inliner_min 41 (+20) +95.24%
array_len_inliner_min 192 (+84) +77.78%
fold_after_inlined_calls_inliner_min 62 (+27) +77.14%
trait_as_return_type_inliner_zero 36 (+14) +63.64%
missing_closure_env_inliner_zero 42 (+16) +61.54%
regression_4124_inliner_min 88 (+33) +60.00%
trait_impl_base_type_inliner_min 396 (+146) +58.40%
regression_7128_inliner_min 227 (+81) +55.48%
brillig_acir_as_brillig_inliner_min 174 (+61) +53.98%
closures_mut_ref_inliner_zero 51 (+17) +50.00%
brillig_not_inliner_min 55 (+18) +48.65%
derive_inliner_min 863 (+279) +47.77%
regression_6451_inliner_min 84 (+26) +44.83%
global_var_regression_simple_inliner_min 234 (+67) +40.12%
import_inliner_min 186 (+52) +38.81%
binary_operator_overloading_inliner_min 621 (+173) +38.62%
wrapping_operations_inliner_min 144 (+40) +38.46%
modules_inliner_min 37 (+9) +32.14%
modules_more_inliner_min 37 (+9) +32.14%
regression_11294_inliner_min 627 (+152) +32.00%
brillig_calls_inliner_min 254 (+61) +31.61%
regression_method_cannot_be_found_inliner_min 107 (+25) +30.49%
unary_operator_overloading_inliner_min 93 (+21) +29.17%
hashmap_inliner_min 12,577 (+2,806) +28.72%
field_attribute_inliner_min 36 (+8) +28.57%
4_sub_inliner_min 73 (+16) +28.07%
double_verify_honk_proof_inliner_min 103 (+22) +27.16%
5_over_inliner_min 78 (+16) +25.81%
pedersen_commitment_inliner_min 201 (+40) +24.84%
double_verify_proof_inliner_min 101 (+20) +24.69%
regression_3051_inliner_min 240 (+47) +24.35%
submodules_inliner_zero 36 (+7) +24.14%
global_consts_inliner_min 314 (+61) +24.11%
generics_inliner_min 302 (+58) +23.77%
to_bytes_integration_inliner_min 220 (+42) +23.60%
no_predicates_brillig_inliner_min 48 (+9) +23.08%
prelude_inliner_min 279 (+52) +22.91%
brillig_rc_regression_6123_inliner_min 282 (+52) +22.61%
regression_inliner_min 1,337 (+227) +20.45%
conditional_2_inliner_min 197 (+33) +20.12%
regression_5435_inliner_min 49 (+8) +19.51%
submodules_inliner_min 45 (+7) +18.42%
reference_only_used_as_alias_inliner_min 373 (+58) +18.41%
to_bytes_consistent_inliner_min 92 (+14) +17.95%
brillig_calls_conditionals_inliner_min 158 (+24) +17.91%
regression_4088_inliner_min 66 (+10) +17.86%
slice_dynamic_index_inliner_max 2,500 (+377) +17.76%
slice_dynamic_index_inliner_zero 2,500 (+377) +17.76%
uhashmap_inliner_min 9,802 (+1,464) +17.56%
to_le_bytes_inliner_min 189 (+28) +17.39%
verify_honk_proof_inliner_min 81 (+12) +17.39%
pedersen_check_inliner_min 651 (+94) +16.88%
brillig_uninitialized_arrays_inliner_min 78 (+11) +16.42%
bit_shifts_comptime_inliner_min 50 (+7) +16.28%
bit_shifts_comptime_inliner_zero 50 (+7) +16.28%
single_verify_proof_inliner_min 80 (+11) +15.94%
7_function_inliner_max 551 (+74) +15.51%
databus_inliner_min 85 (+11) +14.86%
pedersen_hash_inliner_min 409 (+51) +14.25%
brillig_blake2s_inliner_min 172 (+21) +13.91%
regression_6674_3_inliner_min 944 (+107) +12.78%
inline_decompose_hint_brillig_call_inliner_min 274 (+31) +12.76%
simple_2d_array_inliner_min 164 (+18) +12.33%
u16_support_inliner_min 73 (+8) +12.31%
nested_array_in_slice_inliner_max 1,132 (+118) +11.64%
loop_keyword_inliner_min 69 (+7) +11.29%
loop_keyword_inliner_zero 69 (+7) +11.29%
merkle_insert_inliner_min 535 (+54) +11.23%
references_inliner_min 468 (+47) +11.16%
strings_inliner_min 1,264 (+126) +11.07%
regression_6674_1_inliner_max 203 (+20) +10.93%
regression_6674_2_inliner_max 206 (+20) +10.75%
array_eq_inliner_min 117 (+11) +10.38%
array_neq_inliner_min 118 (+11) +10.28%
7_function_inliner_min 700 (+65) +10.24%
slice_loop_inliner_min 359 (+32) +9.79%
array_sort_inliner_min 389 (+34) +9.58%
simple_shield_inliner_min 926 (+78) +9.20%
regression_7062_inliner_min 119 (+10) +9.17%
side_effects_constrain_array_inliner_min 135 (+11) +8.87%
nested_array_dynamic_inliner_max 2,145 (+172) +8.72%
6_array_inliner_min 502 (+40) +8.66%
slice_regex_inliner_max 2,250 (+174) +8.38%
fmtstr_with_global_inliner_min 131 (+10) +8.26%
slice_regex_inliner_min 2,224 (+169) +8.22%
brillig_pedersen_inliner_min 598 (+41) +7.36%
simple_print_inliner_min 249 (+17) +7.33%
7_inliner_min 165 (+11) +7.14%
blake3_inliner_min 165 (+11) +7.14%
regression_5045_inliner_min 240 (+16) +7.14%
signed_division_inliner_min 246 (+16) +6.96%
embedded_curve_ops_inliner_min 550 (+35) +6.80%
higher_order_functions_inliner_min 1,438 (+89) +6.60%
hash_to_field_inliner_min 227 (+14) +6.57%
regression_3394_inliner_min 132 (+8) +6.45%
to_be_bytes_inliner_min 239 (+14) +6.22%
u128_inliner_min 2,418 (+139) +6.10%
conditional_regression_short_circuit_inliner_min 1,179 (+60) +5.36%
sha256_var_witness_const_regression_inliner_min 1,034 (+50) +5.08%
brillig_cow_regression_inliner_min 2,433 (+116) +5.01%
strings_inliner_zero 970 (+45) +4.86%
6_inliner_min 1,066 (+48) +4.72%
ram_blowup_regression_inliner_min 1,182 (+52) +4.60%
regression_4449_inliner_min 1,115 (+49) +4.60%
sha256_brillig_performance_regression_inliner_min 1,922 (+84) +4.57%
debug_logs_inliner_min 10,190 (+439) +4.50%
bigint_inliner_min 2,067 (+88) +4.45%
pedersen_check_inliner_zero 521 (+22) +4.41%
simple_shield_inliner_zero 751 (+31) +4.31%
slices_inliner_min 2,623 (+106) +4.21%
fold_numeric_generic_poseidon_inliner_min 658 (+26) +4.11%
array_dynamic_nested_blackbox_input_inliner_min 1,249 (+49) +4.08%
slice_regex_inliner_zero 1,665 (+65) +4.06%
ecdsa_secp256k1_inliner_min 1,262 (+49) +4.04%
sha256_var_size_regression_inliner_min 1,289 (+50) +4.04%
regression_6674_3_inliner_max 474 (+18) +3.95%
to_bytes_consistent_inliner_zero 81 (+3) +3.85%
array_dynamic_blackbox_input_inliner_min 1,324 (+49) +3.84%
struct_inputs_inliner_min 303 (+11) +3.77%
sha256_inliner_min 1,458 (+50) +3.55%
tuple_inputs_inliner_min 321 (+11) +3.55%
fold_complex_outputs_inliner_min 732 (+25) +3.54%
brillig_cow_inliner_min 332 (+11) +3.43%
sha2_byte_inliner_min 3,086 (+100) +3.35%
array_dedup_regression_inliner_min 273 (+8) +3.02%
conditional_1_inliner_min 1,456 (+38) +2.68%
aes128_encrypt_inliner_min 445 (+11) +2.53%
slice_coercion_inliner_min 498 (+12) +2.47%
reference_counts_inliner_min 856 (+17) +2.03%
array_to_slice_inliner_min 1,015 (+20) +2.01%
regression_6674_3_inliner_zero 474 (+9) +1.94%
fold_2_to_17_inliner_max 562 (+10) +1.81%
fold_2_to_17_inliner_zero 402 (+6) +1.52%
sha256_var_padding_regression_inliner_min 3,271 (+39) +1.21%
u128_inliner_max 2,689 (+31) +1.17%
nested_array_in_slice_inliner_min 996 (+11) +1.12%
uhashmap_inliner_zero 7,499 (+79) +1.06%
bench_2_to_17_inliner_zero 290 (+3) +1.05%
poseidon2_inliner_zero 298 (+3) +1.02%
regression_6674_1_inliner_min 299 (+3) +1.01%
regression_6674_2_inliner_min 306 (+3) +0.99%
uhashmap_inliner_max 12,605 (+122) +0.98%
regression_5252_inliner_min 3,576 (+34) +0.96%
bench_2_to_17_inliner_max 318 (+3) +0.95%
poseidon2_inliner_max 325 (+3) +0.93%
bench_2_to_17_inliner_min 370 (+3) +0.82%
poseidon2_inliner_min 377 (+3) +0.80%
poseidon_bn254_hash_width_3_inliner_min 5,023 (+38) +0.76%
poseidon_bn254_hash_inliner_min 5,023 (+38) +0.76%
fold_2_to_17_inliner_min 402 (+3) +0.75%
sha256_regression_inliner_min 5,320 (+39) +0.74%
poseidonsponge_x5_254_inliner_min 3,150 (+21) +0.67%
nested_array_dynamic_inliner_min 1,867 (+11) +0.59%
array_to_slice_inliner_max 690 (+4) +0.58%
hashmap_inliner_max 19,673 (+103) +0.53%
fold_numeric_generic_poseidon_inliner_zero 574 (+3) +0.53%
no_predicates_numeric_generic_poseidon_inliner_zero 574 (+3) +0.53%
no_predicates_numeric_generic_poseidon_inliner_min 635 (+3) +0.47%
hashmap_inliner_zero 7,923 (+34) +0.43%
fold_numeric_generic_poseidon_inliner_max 729 (+3) +0.41%
no_predicates_numeric_generic_poseidon_inliner_max 729 (+3) +0.41%
u128_inliner_zero 1,994 (+8) +0.40%
bigint_inliner_zero 1,870 (+6) +0.32%
sha256_brillig_performance_regression_inliner_zero 1,673 (+3) +0.18%
sha256_var_witness_const_regression_inliner_max 1,250 (+2) +0.16%
sha256_inliner_zero 1,255 (+2) +0.16%
bigint_inliner_max 2,092 (+3) +0.14%
slices_inliner_max 2,115 (+3) +0.14%
array_to_slice_inliner_zero 747 (+1) +0.13%
sha256_var_witness_const_regression_inliner_zero 804 (+1) +0.12%
sha256_var_padding_regression_inliner_max 4,910 (+6) +0.12%
ram_blowup_regression_inliner_max 929 (+1) +0.11%
sha256_inliner_max 2,290 (+2) +0.09%
sha256_var_size_regression_inliner_max 1,664 (+1) +0.06%
sha256_regression_inliner_max 6,687 (+4) +0.06%
regression_4709_inliner_min 133,808 (+67) +0.05%
brillig_cow_regression_inliner_max 2,052 (+1) +0.05%
poseidonsponge_x5_254_inliner_max 4,107 (+2) +0.05%
brillig_cow_regression_inliner_zero 2,090 (+1) +0.05%
regression_5252_inliner_max 4,435 (+2) +0.05%
poseidon_bn254_hash_inliner_max 5,270 (+2) +0.04%
poseidon_bn254_hash_width_3_inliner_max 5,270 (+2) +0.04%
sha256_regression_inliner_zero 4,849 (+1) +0.02%
strings_inliner_max 922 (-6) -0.65%
reference_counts_inliner_zero 658 (-5) -0.75%
hint_black_box_inliner_zero 366 (-3) -0.81%
hint_black_box_inliner_max 320 (-3) -0.93%
higher_order_functions_inliner_max 541 (-6) -1.10%
higher_order_functions_inliner_zero 717 (-12) -1.65%
keccak256_inliner_min 1,511 (-154) -9.25%
array_dynamic_blackbox_input_inliner_zero 901 (-123) -12.01%
conditional_regression_short_circuit_inliner_zero 812 (-113) -12.22%
6_inliner_zero 730 (-113) -13.40%
keccak256_inliner_zero 1,687 (-280) -14.23%

@vezenovm vezenovm changed the title fix(ssa): Check references containing arrays passed to a call in the rc tracker fix(ssa): Check arrays used as a terminator argument in the RC tracker Jan 23, 2025
@vezenovm vezenovm requested a review from aakoshh January 23, 2025 17:03
@vezenovm vezenovm marked this pull request as ready for review January 23, 2025 17:03
Copy link
Contributor

github-actions bot commented Jan 23, 2025

Changes to number of Brillig opcodes executed

Generated at commit: bbeb28e6c00cf615ca7c0cd7f8ceaf861ed45296, compared to commit: 7b0411fa419248535ea23f80a4cb4621cf244fdb

🧾 Summary (10% most significant diffs)

Program Brillig opcodes (+/-) %
brillig_fns_as_values_inliner_min +250 ❌ +1250.00%
brillig_fns_as_values_inliner_zero +160 ❌ +800.00%
trait_as_return_type_inliner_min +127 ❌ +635.00%
struct_inliner_min +141 ❌ +542.31%
brillig_loop_size_regression_inliner_min +103 ❌ +515.00%
brillig_identity_function_inliner_min +85 ❌ +447.37%
1327_concrete_in_generic_inliner_min +83 ❌ +237.14%
diamond_deps_0_inliner_min +46 ❌ +176.92%
array_to_slice_constant_length_inliner_min +24 ❌ +126.32%
trait_as_return_type_inliner_zero +22 ❌ +110.00%
binary_operator_overloading_inliner_min +652 ❌ +102.19%
brillig_not_inliner_min +30 ❌ +96.77%
regression_4124_inliner_min +41 ❌ +74.55%
regression_6451_inliner_min +38 ❌ +73.08%
derive_inliner_min +421 ❌ +69.47%
fold_after_inlined_calls_inliner_min +24 ❌ +68.57%
wrapping_operations_inliner_min +84 ❌ +64.62%
brillig_acir_as_brillig_inliner_min +74 ❌ +63.25%
trait_impl_base_type_inliner_min +156 ❌ +59.32%
global_var_regression_simple_inliner_min +122 ❌ +57.01%
missing_closure_env_inliner_zero +12 ❌ +54.55%

Full diff report 👇
Program Brillig opcodes (+/-) %
brillig_fns_as_values_inliner_min 270 (+250) +1250.00%
brillig_fns_as_values_inliner_zero 180 (+160) +800.00%
trait_as_return_type_inliner_min 147 (+127) +635.00%
struct_inliner_min 167 (+141) +542.31%
brillig_loop_size_regression_inliner_min 123 (+103) +515.00%
brillig_identity_function_inliner_min 104 (+85) +447.37%
1327_concrete_in_generic_inliner_min 118 (+83) +237.14%
diamond_deps_0_inliner_min 72 (+46) +176.92%
array_to_slice_constant_length_inliner_min 43 (+24) +126.32%
trait_as_return_type_inliner_zero 42 (+22) +110.00%
binary_operator_overloading_inliner_min 1,290 (+652) +102.19%
brillig_not_inliner_min 61 (+30) +96.77%
regression_4124_inliner_min 96 (+41) +74.55%
regression_6451_inliner_min 90 (+38) +73.08%
derive_inliner_min 1,027 (+421) +69.47%
fold_after_inlined_calls_inliner_min 59 (+24) +68.57%
wrapping_operations_inliner_min 214 (+84) +64.62%
brillig_acir_as_brillig_inliner_min 191 (+74) +63.25%
trait_impl_base_type_inliner_min 419 (+156) +59.32%
global_var_regression_simple_inliner_min 336 (+122) +57.01%
missing_closure_env_inliner_zero 34 (+12) +54.55%
modules_inliner_min 37 (+13) +54.17%
modules_more_inliner_min 37 (+13) +54.17%
unary_operator_overloading_inliner_min 107 (+37) +52.86%
array_len_inliner_min 307 (+104) +51.23%
field_attribute_inliner_min 36 (+12) +50.00%
import_inliner_min 210 (+70) +50.00%
6_array_inliner_min 4,290 (+1,400) +48.44%
brillig_blake2s_inliner_min 1,553 (+494) +46.65%
4_sub_inliner_min 89 (+28) +45.90%
7_inliner_min 1,542 (+480) +45.20%
blake3_inliner_min 1,542 (+480) +45.20%
no_predicates_brillig_inliner_min 42 (+13) +44.83%
submodules_inliner_zero 36 (+11) +44.00%
5_over_inliner_min 92 (+28) +43.75%
regression_method_cannot_be_found_inliner_min 122 (+37) +43.53%
array_eq_inliner_min 1,683 (+480) +39.90%
array_neq_inliner_min 1,684 (+480) +39.87%
brillig_calls_inliner_min 263 (+74) +39.15%
closures_mut_ref_inliner_zero 47 (+13) +38.24%
signed_division_inliner_min 331 (+84) +34.01%
side_effects_constrain_array_inliner_min 181 (+45) +33.09%
brillig_cow_inliner_min 1,865 (+450) +31.80%
global_consts_inliner_min 2,233 (+536) +31.59%
pedersen_commitment_inliner_min 267 (+64) +31.53%
bit_shifts_comptime_inliner_min 46 (+11) +31.43%
bit_shifts_comptime_inliner_zero 46 (+11) +31.43%
generics_inliner_min 429 (+101) +30.79%
regression_3051_inliner_min 260 (+59) +29.35%
submodules_inliner_min 49 (+11) +28.95%
prelude_inliner_min 303 (+68) +28.94%
regression_inliner_min 3,941 (+884) +28.92%
pedersen_check_inliner_min 1,197 (+265) +28.43%
conditional_2_inliner_min 201 (+43) +27.22%
strings_inliner_min 3,655 (+759) +26.21%
nested_array_in_slice_inliner_min 2,171 (+450) +26.15%
sha2_byte_inliner_min 112,439 (+23,058) +25.80%
hashmap_inliner_min 113,149 (+22,944) +25.44%
regression_11294_inliner_min 2,261 (+439) +24.09%
brillig_uninitialized_arrays_inliner_min 79 (+15) +23.44%
brillig_rc_regression_6123_inliner_min 443 (+84) +23.40%
regression_4088_inliner_min 74 (+14) +23.33%
struct_inputs_inliner_min 812 (+150) +22.66%
u128_inliner_min 63,774 (+11,631) +22.31%
simple_shield_inliner_min 3,122 (+560) +21.86%
nested_array_dynamic_inliner_min 4,300 (+765) +21.64%
tuple_inputs_inliner_min 782 (+135) +20.87%
merkle_insert_inliner_min 4,064 (+676) +19.95%
fold_complex_outputs_inliner_min 1,295 (+210) +19.35%
brillig_calls_conditionals_inliner_min 234 (+36) +18.18%
pedersen_hash_inliner_min 647 (+99) +18.07%
regression_7062_inliner_min 93 (+14) +17.72%
simple_2d_array_inliner_min 201 (+30) +17.54%
databus_inliner_min 101 (+15) +17.44%
uhashmap_inliner_min 229,685 (+33,067) +16.82%
brillig_pedersen_inliner_min 1,081 (+149) +15.99%
reference_only_used_as_alias_inliner_min 545 (+70) +14.74%
higher_order_functions_inliner_min 2,627 (+336) +14.67%
u16_support_inliner_min 94 (+12) +14.63%
slice_loop_inliner_min 1,468 (+184) +14.33%
inline_decompose_hint_brillig_call_inliner_min 313 (+39) +14.23%
aes128_encrypt_inliner_min 3,962 (+480) +13.79%
array_dynamic_nested_blackbox_input_inliner_min 5,577 (+656) +13.33%
pedersen_check_inliner_zero 846 (+97) +12.95%
sha256_inliner_min 18,551 (+2,103) +12.79%
fmtstr_with_global_inliner_min 138 (+14) +11.29%
sha256_var_witness_const_regression_inliner_min 8,538 (+834) +10.83%
loop_keyword_inliner_min 113 (+11) +10.78%
loop_keyword_inliner_zero 113 (+11) +10.78%
simple_print_inliner_min 265 (+25) +10.42%
references_inliner_min 707 (+65) +10.12%
6_inliner_min 9,428 (+833) +9.69%
slice_dynamic_index_inliner_max 4,656 (+408) +9.60%
slice_dynamic_index_inliner_zero 4,656 (+408) +9.60%
conditional_regression_short_circuit_inliner_min 9,534 (+833) +9.57%
7_function_inliner_min 2,852 (+247) +9.48%
regression_3394_inliner_min 139 (+12) +9.45%
reference_counts_inliner_min 1,056 (+86) +8.87%
regression_6674_3_inliner_min 2,140 (+164) +8.30%
ecdsa_secp256k1_inliner_min 8,821 (+656) +8.03%
7_function_inliner_max 2,211 (+152) +7.38%
array_sort_inliner_min 728 (+50) +7.37%
array_to_slice_inliner_min 2,397 (+159) +7.10%
slices_inliner_min 4,560 (+291) +6.82%
slice_regex_inliner_min 9,062 (+572) +6.74%
regression_7128_inliner_min 1,295 (+79) +6.50%
embedded_curve_ops_inliner_min 709 (+43) +6.46%
debug_logs_inliner_min 10,953 (+636) +6.16%
keccak256_inliner_min 33,946 (+1,924) +6.01%
sha256_var_size_regression_inliner_min 23,400 (+1,314) +5.95%
nested_array_in_slice_inliner_max 1,462 (+76) +5.48%
to_bytes_consistent_inliner_min 695 (+36) +5.46%
array_dedup_regression_inliner_min 1,296 (+64) +5.19%
simple_shield_inliner_zero 2,621 (+127) +5.09%
regression_4449_inliner_min 279,322 (+12,869) +4.83%
nested_array_dynamic_inliner_max 3,144 (+136) +4.52%
array_dynamic_blackbox_input_inliner_min 23,141 (+833) +3.73%
slice_coercion_inliner_min 485 (+16) +3.41%
conditional_1_inliner_min 6,130 (+176) +2.96%
regression_6674_1_inliner_max 606 (+16) +2.71%
regression_6674_2_inliner_max 609 (+16) +2.70%
slice_regex_inliner_max 3,184 (+81) +2.61%
sha256_regression_inliner_min 161,184 (+3,852) +2.45%
slice_regex_inliner_zero 3,954 (+92) +2.38%
to_bytes_integration_inliner_min 2,443 (+54) +2.26%
hash_to_field_inliner_min 983 (+18) +1.87%
to_le_bytes_inliner_min 1,140 (+18) +1.60%
sha256_var_padding_regression_inliner_min 270,946 (+3,852) +1.44%
double_verify_proof_inliner_min 2,230 (+31) +1.41%
sha256_brillig_performance_regression_inliner_min 27,172 (+372) +1.39%
regression_6674_3_inliner_max 1,371 (+18) +1.33%
single_verify_proof_inliner_min 1,545 (+15) +0.98%
to_bytes_consistent_inliner_zero 665 (+6) +0.91%
to_be_bytes_inliner_min 2,143 (+18) +0.85%
hashmap_inliner_zero 75,395 (+517) +0.69%
regression_6674_3_inliner_zero 1,371 (+9) +0.66%
fold_numeric_generic_poseidon_inliner_min 5,823 (+37) +0.64%
brillig_cow_regression_inliner_min 546,757 (+3,316) +0.61%
ram_blowup_regression_inliner_min 822,774 (+4,784) +0.58%
uhashmap_inliner_zero 175,403 (+792) +0.45%
poseidon2_inliner_max 677 (+3) +0.45%
double_verify_honk_proof_inliner_min 7,509 (+32) +0.43%
poseidon2_inliner_zero 729 (+3) +0.41%
verify_honk_proof_inliner_min 4,234 (+16) +0.38%
poseidon2_inliner_min 872 (+3) +0.35%
uhashmap_inliner_max 137,172 (+415) +0.30%
regression_6674_1_inliner_min 1,045 (+3) +0.29%
regression_6674_2_inliner_min 1,051 (+3) +0.29%
array_to_slice_inliner_max 1,625 (+4) +0.25%
hashmap_inliner_max 48,297 (+100) +0.21%
u128_inliner_max 24,276 (+27) +0.11%
fold_numeric_generic_poseidon_inliner_zero 5,719 (+6) +0.11%
no_predicates_numeric_generic_poseidon_inliner_zero 5,719 (+6) +0.11%
no_predicates_numeric_generic_poseidon_inliner_min 5,792 (+6) +0.10%
slices_inliner_max 3,259 (+3) +0.09%
sha256_brillig_performance_regression_inliner_zero 26,448 (+24) +0.09%
slices_inliner_zero 3,664 (+3) +0.08%
fold_numeric_generic_poseidon_inliner_max 4,770 (+3) +0.06%
no_predicates_numeric_generic_poseidon_inliner_max 4,770 (+3) +0.06%
array_to_slice_inliner_zero 1,962 (+1) +0.05%
poseidon_bn254_hash_inliner_min 183,751 (+49) +0.03%
poseidon_bn254_hash_width_3_inliner_min 183,751 (+49) +0.03%
u128_inliner_zero 44,459 (+11) +0.02%
sha256_var_witness_const_regression_inliner_max 6,269 (+1) +0.02%
poseidonsponge_x5_254_inliner_min 204,298 (+25) +0.01%
regression_5252_inliner_min 1,021,124 (+86) +0.01%
sha256_inliner_max 13,199 (+1) +0.01%
sha256_var_size_regression_inliner_max 15,504 (+1) +0.01%
regression_4709_inliner_min 1,064,106 (+61) +0.01%
sha256_regression_inliner_max 111,644 (+4) +0.00%
sha256_var_padding_regression_inliner_max 196,670 (+6) +0.00%
poseidon_bn254_hash_inliner_max 151,736 (+2) +0.00%
poseidon_bn254_hash_width_3_inliner_max 151,736 (+2) +0.00%
regression_5252_inliner_max 854,152 (+10) +0.00%
poseidonsponge_x5_254_inliner_max 171,517 (+2) +0.00%
fold_2_to_17_inliner_max 1,056,633 (+10) +0.00%
sha256_regression_inliner_zero 155,324 (+1) +0.00%
bench_2_to_17_inliner_max 570,236 (+3) +0.00%
bench_2_to_17_inliner_zero 612,719 (+3) +0.00%
fold_2_to_17_inliner_zero 1,317,622 (+6) +0.00%
fold_2_to_17_inliner_min 1,355,057 (+6) +0.00%
bench_2_to_17_inliner_min 712,415 (+3) +0.00%
brillig_cow_regression_inliner_max 454,763 (+1) +0.00%
brillig_cow_regression_inliner_zero 540,399 (+1) +0.00%
ram_blowup_regression_inliner_max 683,268 (+1) +0.00%
strings_inliner_zero 2,074 (-3) -0.14%
hint_black_box_inliner_zero 997 (-3) -0.30%
strings_inliner_max 1,716 (-6) -0.35%
hint_black_box_inliner_max 666 (-3) -0.45%
higher_order_functions_inliner_max 883 (-6) -0.67%
array_dynamic_blackbox_input_inliner_zero 21,081 (-189) -0.89%
higher_order_functions_inliner_zero 1,316 (-12) -0.90%
conditional_regression_short_circuit_inliner_zero 7,819 (-93) -1.18%
6_inliner_zero 7,739 (-93) -1.19%
keccak256_inliner_zero 30,819 (-822) -2.60%

Copy link
Contributor

@github-actions github-actions bot left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Performance Alert ⚠️

Possible performance regression was detected for benchmark 'Compilation Time'.
Benchmark result of this commit is worse than the previous benchmark result exceeding threshold 1.20.

Benchmark suite Current: 55b75cf Previous: 2d415ca Ratio
rollup-block-root-single-tx 110 s 89.7 s 1.23

This comment was automatically generated by workflow using github-action-benchmark.

CC: @TomAFrench

@aakoshh aakoshh force-pushed the mv/check-ref-containing-array-rc-tracker branch from dd04047 to b8b5935 Compare January 23, 2025 21:36
Copy link
Contributor

@aakoshh aakoshh left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Awesome, thanks!

Copy link
Contributor

github-actions bot commented Jan 23, 2025

Changes to circuit sizes

Generated at commit: bbeb28e6c00cf615ca7c0cd7f8ceaf861ed45296, compared to commit: 7b0411fa419248535ea23f80a4cb4621cf244fdb

🧾 Summary (10% most significant diffs)

Program ACIR opcodes (+/-) % Circuit size (+/-) %
sha256_var_size_regression +4 ❌ +0.04% +8 ❌ +0.01%

Full diff report 👇
Program ACIR opcodes (+/-) % Circuit size (+/-) %
sha256_var_size_regression 10,196 (+4) +0.04% 62,971 (+8) +0.01%

@aakoshh
Copy link
Contributor

aakoshh commented Jan 23, 2025

Looking at the increase in the opcodes executed, one difference between this and mine is that I only did the special treatment during the preprocessing, but when the functions were fully inlined it was removed. Do you reckon something like that for the final pass (maybe piggybacking on the flattened flag) should be used?

@vezenovm
Copy link
Contributor Author

vezenovm commented Jan 23, 2025

Looking at the increase in the opcodes executed, one difference between this and mine is that I only did the special treatment during the preprocessing, but when the functions were fully inlined it was removed. Do you reckon something like that for the final pass (maybe piggybacking on the flattened flag) should be used?

Ah yes good call out. I think we can do that as a follow-up optimization as we want will want to have some better tests around under what circumstances we do not check the terminator (e.g. are we actually fully inlined?). For now, let's just get this fix in.

@aakoshh
Copy link
Contributor

aakoshh commented Jan 23, 2025

I tried commenting out preprocessing and the terminator marking separately and together and they did not make a difference in the output of this:

❯ cargo run -q -p nargo_cli -- --program-dir test_programs/execution_success/brillig_fns_as_values info --force --silence-warnings --skip-underconstrained-check --skip-brillig-constraints-check --force-brillig --inliner-aggressiveness 0

+-----------------------+----------+----------------------+--------------+-----------------+
| Package               | Function | Expression Width     | ACIR Opcodes | Brillig Opcodes |
+-----------------------+----------+----------------------+--------------+-----------------+
| brillig_fns_as_values | main     | Bounded { width: 4 } | 1            | 170             |
+-----------------------+----------+----------------------+--------------+-----------------+
| brillig_fns_as_values | main     | N/A                  | N/A          | 170             |
+-----------------------+----------+----------------------+--------------+-----------------+

@aakoshh
Copy link
Contributor

aakoshh commented Jan 23, 2025

It's probably down to the change in the change in rules in which functions to preprocess.

@aakoshh aakoshh merged commit 384cc38 into af/fix-11249 Jan 23, 2025
97 checks passed
@aakoshh aakoshh deleted the mv/check-ref-containing-array-rc-tracker branch January 23, 2025 22:03
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

Successfully merging this pull request may close these issues.

3 participants