Files
noah 5501dfd66d
main-release-gate / verify-and-release (push) Canceled after 0s
Benchmark captured BM1366 report poll path
2026-10-16 17:02:02 -06:00

470 lines
14 KiB
Rust

use alkane_os::bm1362::{
bt8d_for_baud, chain_inactive, encode_job, encode_work as encode_bm1362_work, read_register,
read_register_all, set_chip_address, write_register, write_register_all, Job, S19J_PRO,
};
use alkane_os::bm1366::{decode_nonce_report, encode_work};
use alkane_os::bm13xx::{crc16, crc5};
use alkane_os::difficulty::PoolDifficulty;
use alkane_os::hal_wire::HalClient;
use alkane_os::miner::Bm1366Miner;
use alkane_os::pow::verify_sha256_report;
use alkane_os::pow::VersionMask;
use alkane_os::scrypt_pow::verify_scrypt_header;
use alkane_os::stratum_session::PoolSession;
use alkane_os::stratum_submit::{format_submission, Submission};
use alkane_os::stratum_v1::{
parse_boolean_response, parse_configure_result, parse_control_notification, parse_notify,
parse_subscription, Subscription,
};
use alkane_os::stratum_wire::{
authorize_request, configure_request, subscribe_request, StratumWire,
};
use alkane_os::stratum_work::Sha256Job;
use alkane_os::{power_decision, target_matrix, HardwareBackend};
use std::hint::black_box;
use std::io::{Read, Write};
use std::net::TcpListener;
use std::os::unix::net::UnixStream;
use std::thread;
use std::time::{Duration, Instant};
fn sample(iterations: u64, f: &mut impl FnMut()) -> Duration {
let started = Instant::now();
for _ in 0..iterations {
f();
}
started.elapsed()
}
fn measure(name: &str, minimum_iterations: u64, mut f: impl FnMut()) {
for _ in 0..minimum_iterations.min(1000) {
f();
}
let mut iterations = minimum_iterations.max(1);
while sample(iterations, &mut f) < Duration::from_millis(20) && iterations < 100_000_000 {
iterations = (iterations * 2).min(100_000_000);
}
let mut measurements = [0_f64; 7];
for value in &mut measurements {
*value = sample(iterations, &mut f).as_nanos() as f64 / iterations as f64;
}
measurements.sort_by(f64::total_cmp);
let ns = measurements[measurements.len() / 2];
println!("BENCH {name} {ns:.3} ns/op");
}
#[test]
#[ignore = "microbenchmark"]
fn bench_target_matrix() {
measure("target_matrix", 20_000, || {
black_box(
target_matrix()
.filter(|target| black_box(target.chip.algorithm) == alkane_os::Algorithm::Sha256)
.count(),
);
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_power_policy() {
measure("power_policy", 100_000, || {
black_box(power_decision(black_box(Some(64_000)), 80_000));
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_bm13xx_crc5() {
let command = [0x53, 0x05, 0, 0];
measure("bm13xx_crc5", 100_000, || {
black_box(crc5(black_box(&command)));
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_bm13xx_crc16() {
let job = [0x21_u8; 84];
measure("bm13xx_crc16", 20_000, || {
black_box(crc16(black_box(&job)));
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_share_verification() {
let header = [0_u8; 80];
let target = [0xff_u8; 32];
measure("share_verification", 20_000, || {
black_box(verify_sha256_report(
black_box(&header),
black_box(0xEDAD_FF38),
black_box(0x04B3),
black_box(&target),
));
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_scrypt_share_verification() {
let header = [0_u8; 80];
let target = [0xff_u8; 32];
measure("scrypt_share_verification", 4, || {
black_box(verify_scrypt_header(black_box(&header), black_box(&target)));
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_bm1366_work_encoding() {
let header = [0_u8; 80];
measure("bm1366_work_encoding", 20_000, || {
black_box(encode_work(black_box(&header), black_box(0x18)));
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_bm1362_commands() {
measure("bm1362_commands", 20_000, || {
black_box(chain_inactive());
black_box(set_chip_address(black_box(8)));
black_box(read_register(black_box(0x40), 0x1c));
black_box(read_register_all(0));
black_box(write_register(black_box(0x40), 0x18, 0x7a31));
black_box(write_register_all(0x80, 0));
black_box(bt8d_for_baud(black_box(115_200)));
black_box(S19J_PRO.chip_addresses().last());
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_bm1362_job_encoding() {
let job = Job {
work_id: 8,
num_midstates: 1,
start_nonce: 0,
nbits: 0x1a1f_2c34,
ntime: 0x5e9b_3cd4,
merkle_root: [0xa5; 32],
previous_hash: [0x5a; 32],
version: 0x2000_0000,
};
measure("bm1362_job_encoding", 20_000, || {
black_box(encode_job(black_box(&job)));
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_bm1362_work_encoding() {
let header = [0_u8; 80];
measure("bm1362_work_encoding", 20_000, || {
black_box(encode_bm1362_work(black_box(&header), black_box(8)));
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_bm1366_report_decode() {
let report = [
0xaa, 0x55, 0x38, 0xff, 0xad, 0xed, 0, 0x18, 0x04, 0xb3, 0x94,
];
measure("bm1366_report_decode", 100_000, || {
let _ = black_box(decode_nonce_report(black_box(&report)));
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_stratum_header() {
let job = Sha256Job {
prevhash_stratum: [0; 32],
coinb1: vec![0; 48],
coinb2: vec![0; 64],
merkle_branches: vec![[0; 32]; 4],
version: 0x2000_0000,
nbits: 0x1d00_ffff,
ntime: 0x6655_4433,
extranonce1: vec![0; 4],
extranonce2_size: 8,
};
measure("stratum_header", 5_000, || {
black_box(
job.nonce_zero_header(black_box(&[0; 8]), job.ntime)
.unwrap(),
);
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_stratum_submission() {
let share = Submission {
request_id: 1,
worker: "miner.worker",
job_id: "job-123",
extranonce2: &[0; 8],
ntime: 0x680f_6a2e,
nonce: 0xedad_ff38,
base_version: 0x2000_0000,
rolled_version: 0x2096_6000,
version_mask: Some(VersionMask::new(0x1fff_e000).unwrap()),
};
measure("stratum_submission", 20_000, || {
black_box(format_submission(black_box(&share)).unwrap());
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_stratum_authorize_format() {
measure("stratum_authorize_format", 20_000, || {
black_box(authorize_request(black_box(3), "miner.worker", "password").unwrap());
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_stratum_configure_format() {
measure("stratum_configure_format", 20_000, || {
black_box(configure_request(black_box(1)));
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_stratum_subscribe_format() {
measure("stratum_subscribe_format", 20_000, || {
black_box(subscribe_request(black_box(2), "alkane-os/0.1").unwrap());
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_stratum_subscription_parse() {
let line = br#"{"id":1,"result":[[["mining.notify","session"]],"01020304",4],"error":null}"#;
measure("stratum_subscription_parse", 20_000, || {
black_box(parse_subscription(black_box(line), black_box(1)).unwrap());
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_stratum_accept_parse() {
let line = br#"{"id":5,"result":true,"error":null}"#;
measure("stratum_accept_parse", 20_000, || {
black_box(parse_boolean_response(black_box(line), black_box(5)).unwrap());
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_stratum_notify_parse() {
let line = serde_json::json!({
"id": null,
"method": "mining.notify",
"params": [
"job-1",
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
"616263", "78797a", [], "20000000", "1d00ffff", "66554433", true
]
})
.to_string();
let subscription = Subscription {
extranonce1: vec![1, 2, 3, 4],
extranonce2_size: 4,
};
measure("stratum_notify_parse", 20_000, || {
black_box(parse_notify(black_box(line.as_bytes()), &subscription).unwrap());
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_stratum_control_parse() {
let line = br#"{"id":null,"method":"mining.set_difficulty","params":[2048.5]}"#;
measure("stratum_control_parse", 20_000, || {
black_box(parse_control_notification(black_box(line), false, false).unwrap());
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_stratum_configure_parse() {
let line = br#"{"id":1,"result":{"version-rolling":true,"version-rolling.mask":"1fffe000","subscribe-extranonce":true},"error":null}"#;
measure("stratum_configure_parse", 20_000, || {
black_box(parse_configure_result(black_box(line), 1).unwrap());
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_difficulty_target() {
let number = serde_json::from_str("2048.5").unwrap();
let difficulty = PoolDifficulty::from_json_number(&number).unwrap();
measure("difficulty_target", 20_000, || {
black_box(black_box(difficulty).target_le());
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_stratum_job_issue() {
let line = serde_json::json!({
"id": null,
"method": "mining.notify",
"params": [
"job-1", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
"616263", "78797a", [], "20000000", "1d00ffff", "66554433", true
]
})
.to_string();
let mut session = PoolSession::new(
Subscription {
extranonce1: vec![1, 2, 3, 4],
extranonce2_size: 4,
},
None,
false,
)
.unwrap();
session
.control(br#"{"id":null,"method":"mining.set_difficulty","params":[1]}"#)
.unwrap();
measure("stratum_job_issue", 5_000, || {
session.after_hardware_reset();
black_box(session.issue_notify(black_box(line.as_bytes())).unwrap());
});
}
struct BenchBackend {
report: Option<[u8; 11]>,
}
impl HardwareBackend for BenchBackend {
type Error = ();
fn send_frame(&mut self, _chain: u8, frame: &[u8]) -> Result<(), Self::Error> {
black_box(frame);
Ok(())
}
fn receive_frame(&mut self, _chain: u8, frame: &mut [u8]) -> Result<usize, Self::Error> {
if let Some(report) = self.report {
frame[..report.len()].copy_from_slice(&report);
Ok(report.len())
} else {
Ok(0)
}
}
fn set_chain_reset(&mut self, _chain: u8, _asserted: bool) -> Result<(), Self::Error> {
Ok(())
}
fn set_fan_target(&mut self, _fan: u8, _percent: u8) -> Result<(), Self::Error> {
Ok(())
}
fn read_temperature_mc(&mut self, _sensor: u8) -> Result<i32, Self::Error> {
Ok(50_000)
}
fn set_psu_enabled(&mut self, _enabled: bool) -> Result<(), Self::Error> {
Ok(())
}
}
#[test]
#[ignore = "microbenchmark"]
fn bench_bm1366_session_cycle() {
let header = [0_u8; 80];
let target = [0xff_u8; 32];
measure("bm1366_session_cycle", 20_000, || {
let mut backend = BenchBackend { report: None };
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
miner.start().unwrap();
miner
.submit(black_box(header), black_box(target), 0x18)
.unwrap();
black_box(miner.poll().unwrap());
miner.stop().unwrap();
});
}
#[test]
#[ignore = "microbenchmark"]
fn bench_bm1366_captured_report_poll() {
let header = [
0x00, 0x00, 0x00, 0x20, 0xfc, 0x3a, 0xb8, 0xd4, 0x30, 0x21, 0xf4, 0x5e, 0xb6, 0x62, 0x38,
0x9d, 0x0f, 0x79, 0x1f, 0x65, 0x7d, 0xbf, 0x75, 0xa5, 0xcb, 0x93, 0x67, 0x0b, 0x57, 0xb6,
0xc2, 0x25, 0x03, 0xb4, 0x21, 0x3a, 0x43, 0xae, 0x10, 0x52, 0xeb, 0xd4, 0x44, 0x43, 0x06,
0x8f, 0xe1, 0x78, 0xe2, 0xc6, 0x1c, 0xa4, 0x99, 0x48, 0x46, 0xfd, 0x13, 0x3a, 0xdd, 0xb0,
0x4a, 0xab, 0x2b, 0x38, 0x2c, 0x5b, 0x4c, 0x74, 0xc1, 0x01, 0x2e, 0x6a, 0x8f, 0x06, 0x02,
0x17, 0x00, 0x00, 0x00, 0x00,
];
let report = [
0xaa, 0x55, 0x38, 0xff, 0xad, 0xed, 0, 0x18, 0x04, 0xb3, 0x94,
];
let mut target = [0_u8; 32];
target[26..28].fill(0xff);
let mut backend = BenchBackend {
report: Some(report),
};
let mut miner = Bm1366Miner::new(&mut backend, 0, 0, 0, 100, 80_000).unwrap();
miner.start().unwrap();
miner.submit(header, target, 0x18).unwrap();
measure("bm1366_captured_report_poll", 20_000, || {
let share = miner.poll().unwrap().unwrap();
assert_eq!(black_box(share).nonce, 0xedad_ff38);
});
miner.stop().unwrap();
}
#[test]
#[ignore = "microbenchmark"]
fn bench_hal_socket_exchange() {
let (client, mut server) = UnixStream::pair().unwrap();
let worker = thread::spawn(move || {
let mut header = [0_u8; 16];
let mut payload = [0_u8; 2];
while server.read_exact(&mut header).is_ok() {
assert_eq!(&header[..6], b"ALKH\x01\x04");
assert_eq!(u32::from_le_bytes(header[12..16].try_into().unwrap()), 2);
server.read_exact(&mut payload).unwrap();
assert_eq!(payload, [0, 80]);
header[6..8].copy_from_slice(&1_u16.to_le_bytes());
header[12..16].copy_from_slice(&1_u32.to_le_bytes());
server.write_all(&header).unwrap();
server.write_all(&[0]).unwrap();
}
});
let mut backend = HalClient::from_stream(client).unwrap();
measure("hal_socket_exchange", 100, || {
backend.set_fan_target(black_box(0), black_box(80)).unwrap();
});
drop(backend);
worker.join().unwrap();
}
#[test]
#[ignore = "microbenchmark"]
fn bench_stratum_socket_round_trip() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let address = listener.local_addr().unwrap();
let worker = thread::spawn(move || {
let (mut server, _) = listener.accept().unwrap();
let mut request = [0_u8; 3];
while server.read_exact(&mut request).is_ok() {
assert_eq!(&request, b"{}\n");
server.write_all(b"{}\n").unwrap();
}
});
let mut wire = StratumWire::connect(address, Duration::from_secs(2)).unwrap();
measure("stratum_socket_round_trip", 100, || {
wire.send_line(black_box(b"{}\n")).unwrap();
black_box(wire.read_line().unwrap());
});
drop(wire);
worker.join().unwrap();
}