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.

Sign up for GitHub

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

feat: Copy on write optimization for brillig #3522

Merged
merged 27 commits into from
Nov 28, 2023
Merged

feat: Copy on write optimization for brillig #3522

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
27 commits
Select commit Hold shift + click to select a range
e5f46ff
Add element type to Type::Reference
jfecher Oct 11, 2023
13b9319
Add inc_rc instruction
jfecher Oct 11, 2023
2bafb5d
Add inc_rc instructions to ssa programs
jfecher Oct 11, 2023
946b3e6
Implement inc_rc in brillig
jfecher Oct 11, 2023
995faa4
Implement copy on write optimization in brillig
jfecher Oct 11, 2023
f32889f
Refactor sections
jfecher Oct 12, 2023
d5c80e0
Fix initial reference count
jfecher Oct 17, 2023
cd8be3c
Add reference count to extract_registers
jfecher Oct 17, 2023
d83cf03
Remove dbg panic
jfecher Oct 17, 2023
a7727cc
Cleanup branch_instruction
jfecher Oct 17, 2023
4ef445f
Start refactor to store rc in the first element of the array
jfecher Oct 18, 2023
37654e6
Add reference type to tests
jfecher Oct 20, 2023
edcb040
chore: merge master into reference counters
sirasistant Nov 20, 2023
48806a5
revert: set brillig gen to master
sirasistant Nov 20, 2023
85c63ef
wip: refactor brillig variable vs registerormemory
sirasistant Nov 21, 2023
58f4699
feat: cow optimization
sirasistant Nov 21, 2023
ff526b6
test: restore slice tests
sirasistant Nov 21, 2023
4db9468
refactor: typed references
sirasistant Nov 21, 2023
a3bf20f
test: working on fixing entry point tests
sirasistant Nov 21, 2023
48928fa
test: fix entry point tests
sirasistant Nov 22, 2023
e6afd0d
test: fix dfg test
sirasistant Nov 22, 2023
d8fcb85
fix: remove safety check and address todos
sirasistant Nov 22, 2023
f5f0c06
docs: variable naming and comments
sirasistant Nov 22, 2023
48e72c9
Merge branch 'master' into arv/brillig_reference_counters
sirasistant Nov 24, 2023
9c02007
chore: formatting
sirasistant Nov 24, 2023
9be1d2d
revert: cargo lock
sirasistant Nov 24, 2023
2030653
fix: Fix remaining issues in Brillig's copy on write arrays (#3593)
jfecher Nov 28, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
86 changes: 43 additions & 43 deletions compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,70 +1,70 @@
use acvm::acir::{
brillig::{BlackBoxOp, HeapVector, RegisterOrMemory},
BlackBoxFunc,
};
use acvm::acir::{brillig::BlackBoxOp, BlackBoxFunc};

use crate::brillig::brillig_ir::BrilligContext;
use crate::brillig::brillig_ir::{
brillig_variable::{BrilligVariable, BrilligVector},
BrilligContext,
};

/// Transforms SSA's black box function calls into the corresponding brillig instructions
/// Extracting arguments and results from the SSA function call
/// And making any necessary type conversions to adapt noir's blackbox calls to brillig's
pub(crate) fn convert_black_box_call(
brillig_context: &mut BrilligContext,
bb_func: &BlackBoxFunc,
function_arguments: &[RegisterOrMemory],
function_results: &[RegisterOrMemory],
function_arguments: &[BrilligVariable],
function_results: &[BrilligVariable],
) {
match bb_func {
BlackBoxFunc::SHA256 => {
if let ([message], [RegisterOrMemory::HeapArray(result_array)]) =
if let ([message], [BrilligVariable::BrilligArray(result_array)]) =
(function_arguments, function_results)
{
let message_vector = convert_array_or_vector(brillig_context, message, bb_func);
brillig_context.black_box_op_instruction(BlackBoxOp::Sha256 {
message: message_vector,
output: *result_array,
message: message_vector.to_heap_vector(),
output: result_array.to_heap_array(),
});
} else {
unreachable!("ICE: SHA256 expects one array argument and one array result")
}
}
BlackBoxFunc::Blake2s => {
if let ([message], [RegisterOrMemory::HeapArray(result_array)]) =
if let ([message], [BrilligVariable::BrilligArray(result_array)]) =
(function_arguments, function_results)
{
let message_vector = convert_array_or_vector(brillig_context, message, bb_func);
brillig_context.black_box_op_instruction(BlackBoxOp::Blake2s {
message: message_vector,
output: *result_array,
message: message_vector.to_heap_vector(),
output: result_array.to_heap_array(),
});
} else {
unreachable!("ICE: Blake2s expects one array argument and one array result")
}
}
BlackBoxFunc::Keccak256 => {
if let (
[message, RegisterOrMemory::RegisterIndex(array_size)],
[RegisterOrMemory::HeapArray(result_array)],
[message, BrilligVariable::Simple(array_size)],
[BrilligVariable::BrilligArray(result_array)],
) = (function_arguments, function_results)
{
let mut message_vector = convert_array_or_vector(brillig_context, message, bb_func);
message_vector.size = *array_size;

brillig_context.black_box_op_instruction(BlackBoxOp::Keccak256 {
message: message_vector,
output: *result_array,
message: message_vector.to_heap_vector(),
output: result_array.to_heap_array(),
});
} else {
unreachable!("ICE: Keccak256 expects message, message size and result array")
}
}
BlackBoxFunc::HashToField128Security => {
if let ([message], [RegisterOrMemory::RegisterIndex(result_register)]) =
if let ([message], [BrilligVariable::Simple(result_register)]) =
(function_arguments, function_results)
{
let message_vector = convert_array_or_vector(brillig_context, message, bb_func);
brillig_context.black_box_op_instruction(BlackBoxOp::HashToField128Security {
message: message_vector,
message: message_vector.to_heap_vector(),
output: *result_register,
});
} else {
Expand All @@ -73,17 +73,17 @@ pub(crate) fn convert_black_box_call(
}
BlackBoxFunc::EcdsaSecp256k1 => {
if let (
[RegisterOrMemory::HeapArray(public_key_x), RegisterOrMemory::HeapArray(public_key_y), RegisterOrMemory::HeapArray(signature), message],
[RegisterOrMemory::RegisterIndex(result_register)],
[BrilligVariable::BrilligArray(public_key_x), BrilligVariable::BrilligArray(public_key_y), BrilligVariable::BrilligArray(signature), message],
[BrilligVariable::Simple(result_register)],
) = (function_arguments, function_results)
{
let message_hash_vector =
convert_array_or_vector(brillig_context, message, bb_func);
brillig_context.black_box_op_instruction(BlackBoxOp::EcdsaSecp256k1 {
hashed_msg: message_hash_vector,
public_key_x: *public_key_x,
public_key_y: *public_key_y,
signature: *signature,
hashed_msg: message_hash_vector.to_heap_vector(),
public_key_x: public_key_x.to_heap_array(),
public_key_y: public_key_y.to_heap_array(),
signature: signature.to_heap_array(),
result: *result_register,
});
} else {
Expand All @@ -94,29 +94,29 @@ pub(crate) fn convert_black_box_call(
}
BlackBoxFunc::PedersenCommitment => {
if let (
[message, RegisterOrMemory::RegisterIndex(domain_separator)],
[RegisterOrMemory::HeapArray(result_array)],
[message, BrilligVariable::Simple(domain_separator)],
[BrilligVariable::BrilligArray(result_array)],
) = (function_arguments, function_results)
{
let message_vector = convert_array_or_vector(brillig_context, message, bb_func);
brillig_context.black_box_op_instruction(BlackBoxOp::PedersenCommitment {
inputs: message_vector,
inputs: message_vector.to_heap_vector(),
domain_separator: *domain_separator,
output: *result_array,
output: result_array.to_heap_array(),
});
} else {
unreachable!("ICE: Pedersen expects one array argument, a register for the domain separator, and one array result")
}
}
BlackBoxFunc::PedersenHash => {
if let (
[message, RegisterOrMemory::RegisterIndex(domain_separator)],
[RegisterOrMemory::RegisterIndex(result)],
[message, BrilligVariable::Simple(domain_separator)],
[BrilligVariable::Simple(result)],
) = (function_arguments, function_results)
{
let message_vector = convert_array_or_vector(brillig_context, message, bb_func);
brillig_context.black_box_op_instruction(BlackBoxOp::PedersenHash {
inputs: message_vector,
inputs: message_vector.to_heap_vector(),
domain_separator: *domain_separator,
output: *result,
});
Expand All @@ -126,17 +126,17 @@ pub(crate) fn convert_black_box_call(
}
BlackBoxFunc::SchnorrVerify => {
if let (
[RegisterOrMemory::RegisterIndex(public_key_x), RegisterOrMemory::RegisterIndex(public_key_y), RegisterOrMemory::HeapArray(signature), message],
[RegisterOrMemory::RegisterIndex(result_register)],
[BrilligVariable::Simple(public_key_x), BrilligVariable::Simple(public_key_y), BrilligVariable::BrilligArray(signature), message],
[BrilligVariable::Simple(result_register)],
) = (function_arguments, function_results)
{
let message_hash = convert_array_or_vector(brillig_context, message, bb_func);
let signature = brillig_context.array_to_vector(signature);
brillig_context.black_box_op_instruction(BlackBoxOp::SchnorrVerify {
public_key_x: *public_key_x,
public_key_y: *public_key_y,
message: message_hash,
signature,
message: message_hash.to_heap_vector(),
signature: signature.to_heap_vector(),
result: *result_register,
});
} else {
Expand All @@ -145,14 +145,14 @@ pub(crate) fn convert_black_box_call(
}
BlackBoxFunc::FixedBaseScalarMul => {
if let (
[RegisterOrMemory::RegisterIndex(low), RegisterOrMemory::RegisterIndex(high)],
[RegisterOrMemory::HeapArray(result_array)],
[BrilligVariable::Simple(low), BrilligVariable::Simple(high)],
[BrilligVariable::BrilligArray(result_array)],
) = (function_arguments, function_results)
{
brillig_context.black_box_op_instruction(BlackBoxOp::FixedBaseScalarMul {
low: *low,
high: *high,
result: *result_array,
result: result_array.to_heap_array(),
});
} else {
unreachable!(
Expand All @@ -166,12 +166,12 @@ pub(crate) fn convert_black_box_call(

fn convert_array_or_vector(
brillig_context: &mut BrilligContext,
array_or_vector: &RegisterOrMemory,
array_or_vector: &BrilligVariable,
bb_func: &BlackBoxFunc,
) -> HeapVector {
) -> BrilligVector {
match array_or_vector {
RegisterOrMemory::HeapArray(array) => brillig_context.array_to_vector(array),
RegisterOrMemory::HeapVector(vector) => *vector,
BrilligVariable::BrilligArray(array) => brillig_context.array_to_vector(array),
BrilligVariable::BrilligVector(vector) => *vector,
_ => unreachable!(
"ICE: {} expected an array or a vector, but got {:?}",
bb_func.name(),
Expand Down
Loading
Loading