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

Benchmarking ProtoGalaxy #692

Closed
codygunton opened this issue Aug 18, 2023 · 0 comments · Fixed by AztecProtocol/aztec-packages#3958
Closed

Benchmarking ProtoGalaxy #692

codygunton opened this issue Aug 18, 2023 · 0 comments · Fixed by AztecProtocol/aztec-packages#3958
Assignees
Milestone

Comments

@codygunton
Copy link
Collaborator

No description provided.

@codygunton codygunton added this to the Protogalaxy milestone Aug 18, 2023
@codygunton codygunton self-assigned this Jan 4, 2024
codygunton added a commit to AztecProtocol/aztec-packages that referenced this issue Jan 11, 2024
Benchmark Protogalaxy prover. This just benchmarks the current folding
function. Future PRs will make update and augment with values that will
better reflect performance in production.

Results: uses 16 cores (for the x86 build). `fold_one/N` measures the
time to call the `fold_instances` function to fold a single instance
into an accumulator where the instance sizes are $2^N$. Note this is for
the Ultra arithmetization (so no Goblin, Poseidon2 or DataBus
relations).

```
% taskset -c 0-15 ./bin/protogalaxy_bench                   38s ~/barretenberg-cpp/build cg/pg-bench mainframe
2024-01-11T19:39:49+00:00
Running ./bin/protogalaxy_bench
Run on (128 X 2649.99 MHz CPU s)
CPU Caches:
  L1 Data 32 KiB (x64)
  L1 Instruction 32 KiB (x64)
  L2 Unified 512 KiB (x64)
  L3 Unified 32768 KiB (x8)
Load Average: 3.48, 8.51, 27.24
------------------------------------------------------
Benchmark            Time             CPU   Iterations
------------------------------------------------------
fold_one/14        417 ms          259 ms            3
fold_one/15        668 ms          409 ms            2
fold_one/16       1158 ms          696 ms            1
fold_one/17       2245 ms         1433 ms            1
fold_one/18       4168 ms         2644 ms            1
fold_one/19       7890 ms         5119 ms            1
fold_one/20      15809 ms        10633 ms            1
```

Closes AztecProtocol/barretenberg#692
AztecBot pushed a commit that referenced this issue Jan 12, 2024
Benchmark Protogalaxy prover. This just benchmarks the current folding
function. Future PRs will make update and augment with values that will
better reflect performance in production.

Results: uses 16 cores (for the x86 build). `fold_one/N` measures the
time to call the `fold_instances` function to fold a single instance
into an accumulator where the instance sizes are $2^N$. Note this is for
the Ultra arithmetization (so no Goblin, Poseidon2 or DataBus
relations).

```
% taskset -c 0-15 ./bin/protogalaxy_bench                   38s ~/barretenberg-cpp/build cg/pg-bench mainframe
2024-01-11T19:39:49+00:00
Running ./bin/protogalaxy_bench
Run on (128 X 2649.99 MHz CPU s)
CPU Caches:
  L1 Data 32 KiB (x64)
  L1 Instruction 32 KiB (x64)
  L2 Unified 512 KiB (x64)
  L3 Unified 32768 KiB (x8)
Load Average: 3.48, 8.51, 27.24
------------------------------------------------------
Benchmark            Time             CPU   Iterations
------------------------------------------------------
fold_one/14        417 ms          259 ms            3
fold_one/15        668 ms          409 ms            2
fold_one/16       1158 ms          696 ms            1
fold_one/17       2245 ms         1433 ms            1
fold_one/18       4168 ms         2644 ms            1
fold_one/19       7890 ms         5119 ms            1
fold_one/20      15809 ms        10633 ms            1
```

Closes #692
michaelelliot pushed a commit to Swoir/noir_rs that referenced this issue Feb 28, 2024
Benchmark Protogalaxy prover. This just benchmarks the current folding
function. Future PRs will make update and augment with values that will
better reflect performance in production.

Results: uses 16 cores (for the x86 build). `fold_one/N` measures the
time to call the `fold_instances` function to fold a single instance
into an accumulator where the instance sizes are $2^N$. Note this is for
the Ultra arithmetization (so no Goblin, Poseidon2 or DataBus
relations).

```
% taskset -c 0-15 ./bin/protogalaxy_bench                   38s ~/barretenberg-cpp/build cg/pg-bench mainframe
2024-01-11T19:39:49+00:00
Running ./bin/protogalaxy_bench
Run on (128 X 2649.99 MHz CPU s)
CPU Caches:
  L1 Data 32 KiB (x64)
  L1 Instruction 32 KiB (x64)
  L2 Unified 512 KiB (x64)
  L3 Unified 32768 KiB (x8)
Load Average: 3.48, 8.51, 27.24
------------------------------------------------------
Benchmark            Time             CPU   Iterations
------------------------------------------------------
fold_one/14        417 ms          259 ms            3
fold_one/15        668 ms          409 ms            2
fold_one/16       1158 ms          696 ms            1
fold_one/17       2245 ms         1433 ms            1
fold_one/18       4168 ms         2644 ms            1
fold_one/19       7890 ms         5119 ms            1
fold_one/20      15809 ms        10633 ms            1
```

Closes AztecProtocol/barretenberg#692
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 a pull request may close this issue.

1 participant