Skip to content

Commit

Permalink
feat: extend winning_post bench to allow fake seals (#1571)
Browse files Browse the repository at this point in the history
feat: add a window_post_fake bench for using fake seals
feat: bump default API version in both PoSt benches to current
docs: update documentation on bench usage
  • Loading branch information
cryptonemo authored and vmx committed Jun 28, 2022
1 parent 2e1c77f commit 49c67a7
Show file tree
Hide file tree
Showing 7 changed files with 325 additions and 63 deletions.
10 changes: 6 additions & 4 deletions README.md
Original file line number Diff line number Diff line change
Expand Up @@ -103,12 +103,14 @@ $ cargo +nightly build -p filecoin-proofs --release --target aarch64-unknown-lin

## Benchmarks

The main benchmarking tool is called `benchy`. `benchy` has several subcommands, including `merkleproofs`, `prodbench`, `winning_post` and `window_post`. You can run them with various configuration options, but some examples are below:
The main benchmarking tool is called `benchy`. `benchy` has several subcommands, including `merkleproofs`, `prodbench`, `winning_post`, `window_post` and `window_post_fake` (uses fake sealing for faster benching). Note that `winning_post` now has a `--fake` option for also running fake sealing for faster benching. You can run them with various configuration options, but some examples are below:

```
> cargo run --release --bin benchy -- merkleproofs --size 2
> cargo run --release --bin benchy -- winning-post --size 2
> cargo run --release --bin benchy -- window-post --size 2
> cargo run --release --bin benchy -- merkleproofs --size 2KiB
> cargo run --release --bin benchy -- winning-post --size 2KiB
> cargo run --release --bin benchy -- winning-post --size 2KiB --fake
> cargo run --release --bin benchy -- window-post --size 2KiB
> cargo run --release --bin benchy -- window-post-fake --size 2KiB --fake
> cargo run --release --bin benchy -- prodbench
```

Expand Down
49 changes: 44 additions & 5 deletions fil-proofs-tooling/src/bin/benchy/main.rs
Original file line number Diff line number Diff line change
Expand Up @@ -16,6 +16,7 @@ mod hash_fns;
mod merkleproofs;
mod prodbench;
mod window_post;
mod window_post_fake;
mod winning_post;

fn main() -> Result<()> {
Expand Down Expand Up @@ -84,8 +85,8 @@ fn main() -> Result<()> {
Arg::with_name("api_version")
.long("api-version")
.required(true)
.help("The api_version to use (default: 1.0.0)")
.default_value("1.0.0")
.help("The api_version to use (default: 1.1.0)")
.default_value("1.1.0")
.takes_value(true),
);

Expand All @@ -98,12 +99,42 @@ fn main() -> Result<()> {
.help("The data size (e.g. 2KiB)")
.takes_value(true),
)
.arg(
Arg::with_name("fake")
.long("fake")
.help("Use fake replica (default: false)")
.takes_value(false),
)
.arg(
Arg::with_name("api_version")
.long("api-version")
.required(true)
.help("The api_version to use (default: 1.0.0)")
.default_value("1.0.0")
.help("The api_version to use (default: 1.1.0)")
.default_value("1.1.0")
.takes_value(true),
);

let window_post_fake_cmd = SubCommand::with_name("window-post-fake")
.about("Benchmark Window PoST Fake")
.arg(
Arg::with_name("size")
.long("size")
.required(true)
.help("The data size (e.g. 2KiB)")
.takes_value(true),
)
.arg(
Arg::with_name("fake")
.long("fake")
.help("Use fake replica (default: false)")
.takes_value(false),
)
.arg(
Arg::with_name("api_version")
.long("api-version")
.required(true)
.help("The api_version to use (default: 1.1.0)")
.default_value("1.1.0")
.takes_value(true),
);

Expand Down Expand Up @@ -174,6 +205,7 @@ fn main() -> Result<()> {
.setting(AppSettings::ArgRequiredElseHelp)
.version("0.1")
.subcommand(window_post_cmd)
.subcommand(window_post_fake_cmd)
.subcommand(winning_post_cmd)
.subcommand(hash_cmd)
.subcommand(prodbench_cmd)
Expand Down Expand Up @@ -206,8 +238,15 @@ fn main() -> Result<()> {
}
("winning-post", Some(m)) => {
let sector_size = Byte::from_str(value_t!(m, "size", String)?)?.get_bytes() as usize;
let fake_replica = m.is_present("fake");
let api_version = ApiVersion::from_str(&value_t!(m, "api_version", String)?)?;
winning_post::run(sector_size, fake_replica, api_version)?;
}
("window-post-fake", Some(m)) => {
let sector_size = Byte::from_str(value_t!(m, "size", String)?)?.get_bytes() as usize;
let fake_replica = m.is_present("fake");
let api_version = ApiVersion::from_str(&value_t!(m, "api_version", String)?)?;
winning_post::run(sector_size, api_version)?;
window_post_fake::run(sector_size, fake_replica, api_version)?;
}
("hash-constraints", Some(_m)) => {
hash_fns::run()?;
Expand Down
1 change: 1 addition & 0 deletions fil-proofs-tooling/src/bin/benchy/prodbench.rs
Original file line number Diff line number Diff line change
Expand Up @@ -193,6 +193,7 @@ pub fn run(
sector_size,
inputs.num_sectors as usize,
only_add_piece,
false, /* fake replica */
arbitrary_porep_id,
inputs.api_version(),
);
Expand Down
135 changes: 135 additions & 0 deletions fil-proofs-tooling/src/bin/benchy/window_post_fake.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,135 @@
use std::collections::BTreeMap;
use std::fs::{remove_dir_all, remove_file};
use std::io::stdout;

use fil_proofs_tooling::shared::{create_replica, PROVER_ID, RANDOMNESS};
use fil_proofs_tooling::{measure, Metadata};
use filecoin_proofs::constants::{WINDOW_POST_CHALLENGE_COUNT, WINDOW_POST_SECTOR_COUNT};
use filecoin_proofs::types::{PoStConfig, SectorSize};
use filecoin_proofs::{
generate_window_post, verify_window_post, with_shape, PoStType, PrivateReplicaInfo,
PublicReplicaInfo,
};
use log::info;
use serde::Serialize;
use storage_proofs_core::{api_version::ApiVersion, merkle::MerkleTreeTrait, sector::SectorId};

#[derive(Serialize)]
#[serde(rename_all = "kebab-case")]
struct Inputs {
sector_size: u64,
fake_replica: bool,
}

#[derive(Serialize)]
#[serde(rename_all = "kebab-case")]
struct Outputs {
gen_window_post_cpu_time_ms: u64,
gen_window_post_wall_time_ms: u64,
verify_window_post_cpu_time_ms: u64,
verify_window_post_wall_time_ms: u64,
}

#[derive(Serialize)]
#[serde(rename_all = "kebab-case")]
struct Report {
inputs: Inputs,
outputs: Outputs,
}

impl Report {
/// Print all results to stdout
pub fn print(&self) {
let wrapped = Metadata::wrap(&self).expect("failed to retrieve metadata");
serde_json::to_writer(stdout(), &wrapped).expect("cannot write report JSON to stdout");
}
}

pub fn run_window_post_bench<Tree: 'static + MerkleTreeTrait>(
sector_size: u64,
fake_replica: bool,
api_version: ApiVersion,
) -> anyhow::Result<()> {
let arbitrary_porep_id = [66; 32];
let sector_count = *WINDOW_POST_SECTOR_COUNT
.read()
.expect("WINDOW_POST_SECTOR_COUNT poisoned")
.get(&sector_size)
.expect("unknown sector size");

let (sector_id, replica_output) =
create_replica::<Tree>(sector_size, arbitrary_porep_id, fake_replica, api_version);

// Store the replica's private and publicly facing info for proving and verifying respectively.
let mut pub_replica_info: BTreeMap<SectorId, PublicReplicaInfo> = BTreeMap::new();
let mut priv_replica_info: BTreeMap<SectorId, PrivateReplicaInfo<Tree>> = BTreeMap::new();

pub_replica_info.insert(sector_id, replica_output.public_replica_info.clone());
priv_replica_info.insert(sector_id, replica_output.private_replica_info.clone());

// Measure PoSt generation and verification.
let post_config = PoStConfig {
sector_size: SectorSize(sector_size),
challenge_count: WINDOW_POST_CHALLENGE_COUNT,
sector_count,
typ: PoStType::Window,
priority: false,
api_version,
};

let gen_window_post_measurement = measure(|| {
generate_window_post::<Tree>(&post_config, &RANDOMNESS, &priv_replica_info, PROVER_ID)
})
.expect("failed to generate window post");

let proof = &gen_window_post_measurement.return_value;

let verify_window_post_measurement = measure(|| {
verify_window_post::<Tree>(
&post_config,
&RANDOMNESS,
&pub_replica_info,
PROVER_ID,
proof,
)
})
.expect("failed to verify window post proof");

// Clean-up sealed file.
remove_file(&replica_output.private_replica_info.replica_path())?;
remove_dir_all(&replica_output.private_replica_info.cache_dir_path())?;

// Create a JSON serializable report that we print to stdout (that will later be parsed using
// the CLI JSON parser `jq`).
let report = Report {
inputs: Inputs {
sector_size,
fake_replica,
},
outputs: Outputs {
gen_window_post_cpu_time_ms: gen_window_post_measurement.cpu_time.as_millis() as u64,
gen_window_post_wall_time_ms: gen_window_post_measurement.wall_time.as_millis() as u64,
verify_window_post_cpu_time_ms: verify_window_post_measurement.cpu_time.as_millis()
as u64,
verify_window_post_wall_time_ms: verify_window_post_measurement.wall_time.as_millis()
as u64,
},
};
report.print();
Ok(())
}

pub fn run(sector_size: usize, fake_replica: bool, api_version: ApiVersion) -> anyhow::Result<()> {
info!(
"Benchy Window PoSt Fake: sector-size={}, fake_replica={}, api_version={}",
sector_size, fake_replica, api_version
);

with_shape!(
sector_size as u64,
run_window_post_bench,
sector_size as u64,
fake_replica,
api_version,
)
}
25 changes: 18 additions & 7 deletions fil-proofs-tooling/src/bin/benchy/winning_post.rs
Original file line number Diff line number Diff line change
@@ -1,3 +1,4 @@
use std::fs::{remove_dir_all, remove_file};
use std::io::stdout;

use anyhow::anyhow;
Expand All @@ -18,6 +19,7 @@ use storage_proofs_core::merkle::MerkleTreeTrait;
#[serde(rename_all = "kebab-case")]
struct Inputs {
sector_size: u64,
fake_replica: bool,
}

#[derive(Serialize)]
Expand Down Expand Up @@ -48,6 +50,7 @@ impl Report {

pub fn run_fallback_post_bench<Tree: 'static + MerkleTreeTrait>(
sector_size: u64,
fake_replica: bool,
api_version: ApiVersion,
) -> anyhow::Result<()> {
if WINNING_POST_SECTOR_COUNT != 1 {
Expand All @@ -57,11 +60,11 @@ pub fn run_fallback_post_bench<Tree: 'static + MerkleTreeTrait>(
}
let arbitrary_porep_id = [66; 32];
let (sector_id, replica_output) =
create_replica::<Tree>(sector_size, arbitrary_porep_id, api_version);
create_replica::<Tree>(sector_size, arbitrary_porep_id, fake_replica, api_version);

// Store the replica's private and publicly facing info for proving and verifying respectively.
let pub_replica_info = vec![(sector_id, replica_output.public_replica_info)];
let priv_replica_info = vec![(sector_id, replica_output.private_replica_info)];
let pub_replica_info = vec![(sector_id, replica_output.public_replica_info.clone())];
let priv_replica_info = vec![(sector_id, replica_output.private_replica_info.clone())];

let post_config = PoStConfig {
sector_size: sector_size.into(),
Expand Down Expand Up @@ -100,10 +103,17 @@ pub fn run_fallback_post_bench<Tree: 'static + MerkleTreeTrait>(
})
.expect("failed to verify winning post proof");

// Clean-up sealed file and cache_dir.
remove_file(&replica_output.private_replica_info.replica_path())?;
remove_dir_all(&replica_output.private_replica_info.cache_dir_path())?;

// Create a JSON serializable report that we print to stdout (that will later be parsed using
// the CLI JSON parser `jq`).
let report = Report {
inputs: Inputs { sector_size },
inputs: Inputs {
sector_size,
fake_replica,
},
outputs: Outputs {
gen_winning_post_cpu_time_ms: gen_winning_post_measurement.cpu_time.as_millis() as u64,
gen_winning_post_wall_time_ms: gen_winning_post_measurement.wall_time.as_millis()
Expand All @@ -126,16 +136,17 @@ pub fn run_fallback_post_bench<Tree: 'static + MerkleTreeTrait>(
Ok(())
}

pub fn run(sector_size: usize, api_version: ApiVersion) -> anyhow::Result<()> {
pub fn run(sector_size: usize, fake_replica: bool, api_version: ApiVersion) -> anyhow::Result<()> {
info!(
"Benchy Winning PoSt: sector-size={}, api_version={}",
sector_size, api_version
"Benchy Winning PoSt: sector-size={}, fake_replica={}, api_version={}",
sector_size, fake_replica, api_version
);

with_shape!(
sector_size as u64,
run_fallback_post_bench,
sector_size as u64,
fake_replica,
api_version,
)
}
2 changes: 1 addition & 1 deletion fil-proofs-tooling/src/bin/gpu-cpu-test/main.rs
Original file line number Diff line number Diff line change
Expand Up @@ -140,7 +140,7 @@ fn threads_mode(parallel: u8, gpu_stealing: bool) {

// Create fixtures only once for both threads
let (sector_id, replica_output) =
create_replica::<MerkleTree>(SECTOR_SIZE, arbitrary_porep_id, FIXED_API_VERSION);
create_replica::<MerkleTree>(SECTOR_SIZE, arbitrary_porep_id, false, FIXED_API_VERSION);
let priv_replica_info = (sector_id, replica_output.private_replica_info);

// Put each proof into it's own scope (the other one is due to the if statement)
Expand Down
Loading

0 comments on commit 49c67a7

Please # to comment.