diff --git a/bin/assigner/src/main.cpp b/bin/assigner/src/main.cpp index f5f440fd..9a2ab703 100644 --- a/bin/assigner/src/main.cpp +++ b/bin/assigner/src/main.cpp @@ -90,21 +90,21 @@ void print_circuit(const circuit_proxy &circuit_proxy, using AssignmentTableType = assignment_proxy; using variable_type = crypto3::zk::snark::plonk_variable; - const auto gates = circuit_proxy.gates(); - const std::set& used_gates_idx = circuit_proxy.get_used_gates(); + const auto& gates = circuit_proxy.gates(); + const auto& used_gates_idx = circuit_proxy.get_used_gates(); typename ConstraintSystemType::gates_container_type used_gates; for (const auto &it : used_gates_idx) { used_gates.push_back(gates[it]); } - const auto copy_constraints = circuit_proxy.copy_constraints(); + const auto& copy_constraints = circuit_proxy.copy_constraints(); typename ConstraintSystemType::copy_constraints_container_type used_copy_constraints; - const std::set& used_copy_constraints_idx = circuit_proxy.get_used_copy_constraints(); + const auto& used_copy_constraints_idx = circuit_proxy.get_used_copy_constraints(); for (const auto &it : used_copy_constraints_idx) { used_copy_constraints.push_back(copy_constraints[it]); } if (rename_required) { - const auto used_rows = table_proxy.get_used_rows(); + const auto& used_rows = table_proxy.get_used_rows(); std::uint32_t local_row = 0; for (const auto &row : used_rows) { for (auto &constraint : used_copy_constraints) { @@ -127,16 +127,16 @@ void print_circuit(const circuit_proxy &circuit_proxy, } } - const auto lookup_gates = circuit_proxy.lookup_gates(); + const auto& lookup_gates = circuit_proxy.lookup_gates(); typename ConstraintSystemType::lookup_gates_container_type used_lookup_gates; - const std::set& used_lookup_gates_idx = circuit_proxy.get_used_lookup_gates(); + const auto& used_lookup_gates_idx = circuit_proxy.get_used_lookup_gates(); for (const auto &it : used_lookup_gates_idx) { used_lookup_gates.push_back(lookup_gates[it]); } - const auto lookup_tables = circuit_proxy.lookup_tables(); + const auto& lookup_tables = circuit_proxy.lookup_tables(); typename ConstraintSystemType::lookup_tables_type used_lookup_tables; - const std::set& used_lookup_tables_idx = circuit_proxy.get_used_lookup_tables(); + const auto& used_lookup_tables_idx = circuit_proxy.get_used_lookup_tables(); for (const auto &it : used_lookup_tables_idx) { used_lookup_tables.push_back(lookup_tables[it]); } @@ -144,7 +144,7 @@ void print_circuit(const circuit_proxy &circuit_proxy, auto filled_val = plonk_constraint_system(std::make_tuple( nil::crypto3::marshalling::types::fill_plonk_gates(used_gates), - nil::crypto3::marshalling::types::fill_plonk_copy_constraints(used_copy_constraints), + nil::crypto3::marshalling::types::fill_plonk_copy_constraints(used_copy_constraints), nil::crypto3::marshalling::types::fill_plonk_lookup_gates(used_lookup_gates), nil::crypto3::marshalling::types::fill_plonk_lookup_tables(used_lookup_tables) )); @@ -170,66 +170,19 @@ enum class print_column_kind { SELECTOR }; -template -void fill_vector_value(std::vector &table_values, const assignment_proxy &table_proxy, - print_column_kind column_kind, std::uint32_t num_cols, std::uint32_t num_rows, std::uint32_t padding) { - for(std::size_t i = 0; i < num_cols; i++) { - for(std::size_t j = 0; j < num_rows; j++){ - ValueType val; - switch (column_kind) { - case print_column_kind::WITNESS: { - if (j < table_proxy.witness_column_size(i)) { - table_values.push_back(table_proxy.witness(i, j)); - } else { - table_values.push_back(0); - } - break; - } - case print_column_kind::SHARED: { - if (j < table_proxy.shared_column_size(i)) { - table_values.push_back(table_proxy.shared(i, j)); - } else { - table_values.push_back(0); - } - break; - } - case print_column_kind::PUBLIC_INPUT: { - if (j < table_proxy.public_input_column_size(i)) { - table_values.push_back(table_proxy.public_input(i, j)); - } else { - table_values.push_back(0); - } - break; - } - case print_column_kind::CONSTANT: { - if (j < table_proxy.constant_column_size(i)) { - table_values.push_back(table_proxy.constant(i, j)); - } else { - table_values.push_back(0); - } - break; - } - case print_column_kind::SELECTOR: { - if (j < table_proxy.selector_column_size(i)) { - table_values.push_back(table_proxy.selector(i, j)); - } else { - table_values.push_back(0); - } - break; - } - default: { - table_values.push_back(0); - } - }; - } - for(std::uint32_t j = 0; j < padding; j++){ +template +void fill_vector_value(std::vector &table_values, const ContainerType &table_col, std::uint32_t padding) { + std::copy(table_col.begin(), table_col.end(), std::back_inserter(table_values)); + for(std::uint32_t j = table_col.size(); j < padding; j++){ table_values.push_back(0); } - } } -template -void print_assignment_table(const assignment_proxy &table_proxy, print_table_kind print_kind, std::ostream &out = std::cout) { +template +void print_assignment_table(const assignment_proxy &table_proxy, + print_table_kind print_kind, + std::uint32_t ComponentConstantColumns, std::uint32_t ComponentSelectorColumns, + std::ostream &out = std::cout) { using AssignmentTableType = assignment_proxy; std::uint32_t usable_rows_amount; std::uint32_t total_columns; @@ -238,20 +191,34 @@ void print_assignment_table(const assignment_proxy &table_p std::uint32_t witness_size = table_proxy.witnesses_amount(); std::uint32_t constant_size = table_proxy.constants_amount(); std::uint32_t selector_size = table_proxy.selectors_amount(); + const auto lookup_constant_cols = table_proxy.get_lookup_constant_cols(); + const auto lookup_selector_cols = table_proxy.get_lookup_selector_cols(); if (print_kind == print_table_kind::PRIVATE) { + constant_size = ComponentConstantColumns; + selector_size = ComponentSelectorColumns; total_columns = witness_size + constant_size + selector_size; usable_rows_amount = table_proxy.get_used_rows().size(); } else if (print_kind == print_table_kind::SHARED) { - total_columns = shared_size + public_input_size; + constant_size = constant_size - ComponentConstantColumns; + selector_size = selector_size - ComponentSelectorColumns; + total_columns = shared_size + public_input_size + constant_size + selector_size; std::uint32_t max_shared_size = 0; std::uint32_t max_public_inputs_size = 0; + std::uint32_t max_constant_size = 0; + std::uint32_t max_selector_size = 0; for (std::uint32_t i = 0; i < shared_size; i++) { max_shared_size = std::max(max_shared_size, table_proxy.shared_column_size(i)); } for (std::uint32_t i = 0; i < public_input_size; i++) { max_public_inputs_size = std::max(max_public_inputs_size, table_proxy.public_input_column_size(i)); } - usable_rows_amount = std::max(max_shared_size, max_public_inputs_size); + for (const auto &i : lookup_constant_cols) { + max_constant_size = std::max(max_constant_size, table_proxy.constant_column_size(i)); + } + for (const auto &i : lookup_selector_cols) { + max_selector_size = std::max(max_selector_size, table_proxy.selector_column_size(i)); + } + usable_rows_amount = std::max({max_shared_size, max_public_inputs_size, max_constant_size, max_selector_size}); } else { // FULL total_columns = AssignmentTableType::arithmetization_params::total_columns; std::uint32_t max_witness_size = 0; @@ -280,7 +247,6 @@ void print_assignment_table(const assignment_proxy &table_p if (padded_rows_amount < 8) { padded_rows_amount = 8; } - const std::uint32_t padding = padded_rows_amount - usable_rows_amount; using TTypeBase = nil::marshalling::field_type; using plonk_assignment_table = nil::marshalling::types::bundle< @@ -296,27 +262,51 @@ void print_assignment_table(const assignment_proxy &table_p > > >; + using column_type = typename crypto3::zk::snark::plonk_column; std::vector table_values; if (print_kind == print_table_kind::FULL) { - fill_vector_value - (table_values, table_proxy, print_column_kind::WITNESS, witness_size, usable_rows_amount, padding); - fill_vector_value - (table_values, table_proxy, print_column_kind::PUBLIC_INPUT, public_input_size, usable_rows_amount, padding); - fill_vector_value - (table_values, table_proxy, print_column_kind::CONSTANT, constant_size, usable_rows_amount, padding); - fill_vector_value - (table_values, table_proxy, print_column_kind::SELECTOR, selector_size, usable_rows_amount, padding); + for (std::uint32_t i = 0; i < witness_size; i++) { + fill_vector_value + (table_values, table_proxy.witness(i), padded_rows_amount); + } + for (std::uint32_t i = 0; i < public_input_size; i++) { + fill_vector_value + (table_values, table_proxy.public_input(i), padded_rows_amount); + } + for (std::uint32_t i = 0; i < constant_size; i++) { + fill_vector_value + (table_values, table_proxy.constant(i), padded_rows_amount); + } + for (std::uint32_t i = 0; i < selector_size; i++) { + fill_vector_value + (table_values, table_proxy.selector(i), padded_rows_amount); + } } else if (print_kind == print_table_kind::SHARED) { - fill_vector_value - (table_values, table_proxy, print_column_kind::PUBLIC_INPUT, public_input_size, usable_rows_amount, padding); - fill_vector_value - (table_values, table_proxy, print_column_kind::SHARED, shared_size, usable_rows_amount, padding); + for (std::uint32_t i = 0; i < public_input_size; i++) { + fill_vector_value + (table_values, table_proxy.public_input(i), padded_rows_amount); + } + for (std::uint32_t i = 0; i < shared_size; i++) { + fill_vector_value + (table_values, table_proxy.shared(i), padded_rows_amount); + } + for (std::uint32_t i = 0; i < constant_size; i++) { + fill_vector_value + (table_values, table_proxy.constant(i + ComponentConstantColumns), padded_rows_amount); + } + for (std::uint32_t i = 0; i < selector_size; i++) { + fill_vector_value + (table_values, table_proxy.selector(i + ComponentSelectorColumns), padded_rows_amount); + } } else { - const auto rows = table_proxy.get_used_rows(); + const std::uint32_t padding = padded_rows_amount - usable_rows_amount; + const auto& rows = table_proxy.get_used_rows(); + for( std::size_t i = 0; i < AssignmentTableType::arithmetization_params::witness_columns; i++ ){ + const auto column_size = table_proxy.witness_column_size(i); for(const auto& j : rows){ - if (j < table_proxy.witness_column_size(i)) { + if (j < column_size) { table_values.push_back(table_proxy.witness(i, j)); } else { table_values.push_back(0); @@ -326,9 +316,10 @@ void print_assignment_table(const assignment_proxy &table_p table_values.push_back(0); } } - for( std::size_t i = 0; i < AssignmentTableType::arithmetization_params::constant_columns; i++ ){ + for (std::uint32_t i = 0; i < ComponentConstantColumns; i++) { + const auto column_size = table_proxy.constant_column_size(i); for(const auto& j : rows){ - if (j < table_proxy.constant_column_size(i)) { + if (j < column_size) { table_values.push_back(table_proxy.constant(i, j)); } else { table_values.push_back(0); @@ -338,9 +329,10 @@ void print_assignment_table(const assignment_proxy &table_p table_values.push_back(0); } } - for( std::size_t i = 0; i < AssignmentTableType::arithmetization_params::selector_columns; i++ ){ - for(const auto& j : rows){ - if (j < table_proxy.selector_column_size(i)) { + for (std::uint32_t i = 0; i < ComponentSelectorColumns; i++) { + const auto column_size = table_proxy.selector_column_size(i); + for(const auto& j : rows) { + if (j < column_size) { table_values.push_back(table_proxy.selector(i, j)); } else { table_values.push_back(0); @@ -376,10 +368,16 @@ int curve_dependent_main(std::string bytecode_file_name, const std::string &policy, std::uint32_t max_num_provers) { using BlueprintFieldType = typename CurveType::base_field_type; + + constexpr std::size_t ComponentConstantColumns = 5; + constexpr std::size_t LookupConstantColumns = 30; + constexpr std::size_t ComponentSelectorColumns = 30; + constexpr std::size_t LookupSelectorConstantColumns = 6; + constexpr std::size_t WitnessColumns = 15; constexpr std::size_t PublicInputColumns = 1; - constexpr std::size_t ConstantColumns = 5; - constexpr std::size_t SelectorColumns = 35; + constexpr std::size_t ConstantColumns = ComponentConstantColumns + LookupConstantColumns; + constexpr std::size_t SelectorColumns = ComponentSelectorColumns + LookupSelectorConstantColumns; using ArithmetizationParams = zk::snark::plonk_arithmetization_params; @@ -433,6 +431,26 @@ int curve_dependent_main(std::string bytecode_file_name, ASSERT_MSG(!parser_instance.assignments.empty() && !parser_instance.circuits.empty(), "Not found any proxy for prover" ); + // pack lookup tables + if (parser_instance.circuits[0].get_reserved_tables().size() > 0) { + std::vector lookup_columns_indices; + const std::uint32_t max_usable_rows = 500000; + lookup_columns_indices.resize(LookupConstantColumns); + // fill ComponentConstantColumns, ComponentConstantColumns + 1, ... + std::iota(lookup_columns_indices.begin(), lookup_columns_indices.end(), ComponentConstantColumns); + + auto usable_rows_amount = zk::snark::pack_lookup_tables_horizontal( + parser_instance.circuits[0].get_reserved_indices(), + parser_instance.circuits[0].get_reserved_tables(), + parser_instance.circuits[0].get(), + parser_instance.assignments[0].get(), + lookup_columns_indices, + ComponentSelectorColumns, + parser_instance.assignments[0].allocated_rows(), + max_usable_rows + ); + } + // print shared table std::ofstream shared_otable; const auto print_kind = parser_instance.assignments.size() > 1 ? print_table_kind::SHARED : print_table_kind::FULL; @@ -446,8 +464,8 @@ int curve_dependent_main(std::string bytecode_file_name, print_assignment_table< nil::marshalling::option::big_endian, - ArithmetizationType - >(parser_instance.assignments[0], print_kind, shared_otable); + ArithmetizationType, BlueprintFieldType + >(parser_instance.assignments[0], print_kind, ComponentConstantColumns, ComponentSelectorColumns, shared_otable); shared_otable.close(); @@ -462,15 +480,14 @@ int curve_dependent_main(std::string bytecode_file_name, print_assignment_table< nil::marshalling::option::big_endian, - ArithmetizationType - >(it, print_table_kind::PRIVATE, otable); + ArithmetizationType, BlueprintFieldType + >(it, print_table_kind::PRIVATE, ComponentConstantColumns, ComponentSelectorColumns, otable); // nil::blueprint::profiling_assignment_table(parser_instance.assignmnt, desc.usable_rows_amount, otable); otable.close(); } } - auto assignment_it = parser_instance.assignments.begin(); for (auto& it : parser_instance.circuits) { std::ofstream ocircuit; diff --git a/bin/transpiler/src/main.cpp b/bin/transpiler/src/main.cpp index e9ebae73..965b58f9 100644 --- a/bin/transpiler/src/main.cpp +++ b/bin/transpiler/src/main.cpp @@ -253,8 +253,8 @@ int main(int argc, char *argv[]) { using BlueprintFieldType = typename curve_type::base_field_type; constexpr std::size_t WitnessColumns = 15; constexpr std::size_t PublicInputColumns = 1; - constexpr std::size_t ConstantColumns = 5; - constexpr std::size_t SelectorColumns = 35; + constexpr std::size_t ConstantColumns = 35; + constexpr std::size_t SelectorColumns = 36; using ArithmetizationParams = nil::crypto3::zk::snark::plonk_arithmetization_params