Can be run against https://github.com/mablr/trace2e/commit/136702382d0dca20ab43c82035eca98e293d6319

trace2e_cheating_bench.rs

fn grpc_local(c: &mut Criterion) {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let mut group = c.benchmark_group("grpc_local");

    for (idx, n) in PROVENANCE_SIZES.iter().enumerate() {
        let port = 18800 + idx as u16;
        let addr: std::net::SocketAddr = format!("127.0.0.1:{port}").parse().unwrap();
        let node_id = String::new();
        let provenance = ProvenanceService::new(node_id.clone());
        let file = Resource::new_file("/tmp/bench".to_string());
        let process_mock = Resource::new_process_mock(1);

        let refs: HashSet<LocalizedResource> = (0..*n)
            .map(|i| {
                LocalizedResource::new(node_id.clone(), Resource::new_file(format!("/tmp/ref_{i}")))
            })
            .collect();
        provenance.set_references(file.clone(), refs);

        let p2m = P2mApiService::new(
            SequencerService::default(),
            provenance,
            ComplianceService::default(),
            M2mNop,
        )
        .with_enrolled_resource(1, 3, process_mock, file);

        rt.spawn(async move {
            Server::builder()
                .add_service(P2mServer::new(P2mHandler::new(p2m)))
                .serve(addr)
                .await
                .unwrap();
        });
        std::thread::sleep(std::time::Duration::from_millis(100));

        let mut client =
            rt.block_on(proto::p2m_client::P2mClient::connect(format!("http://{addr}"))).unwrap();

        group.bench_with_input(
            BenchmarkId::from_parameter(format!("{}_resources", n)),
            n,
            |b, _n| {
                b.iter(|| {
                    rt.block_on(async {
                        let grant: proto::messages::Grant = client
                            .p2m_io_request(tonic::Request::new(proto::messages::IoInfo {
                                process_id: 1,
                                file_descriptor: 3,
                                flow: proto::primitives::Flow::Input as i32,
                            }))
                            .await
                            .unwrap()
                            .into_inner();

                        let _: proto::messages::Ack = client
                            .p2m_io_report(tonic::Request::new(proto::messages::IoResult {
                                process_id: 1,
                                file_descriptor: 3,
                                grant_id: grant.id,
                                result: true,
                            }))
                            .await
                            .unwrap()
                            .into_inner();
                    })
                });
            },
        );
    }
    group.finish();
}

fn grpc_distributed(c: &mut Criterion) {
    use trace2e_core::transport::grpc::DEFAULT_GRPC_PORT;

    let mut group = c.benchmark_group("grpc_distributed");

    for num_nodes in NODE_COUNTS {
        // Fresh runtime per parameter so the server on DEFAULT_GRPC_PORT is dropped between iterations
        let rt = tokio::runtime::Runtime::new().unwrap();
        let addr: std::net::SocketAddr = format!("127.0.0.1:{DEFAULT_GRPC_PORT}").parse().unwrap();
        let node1 = addr.ip().to_string();

        // Remote IPs (fake, M2mGrpc::mock() rewrites to 127.0.0.1)
        let remote_ips: Vec<String> = (2..=num_nodes + 1).map(|i| format!("10.0.0.{i}")).collect();

        let refs: HashSet<LocalizedResource> = remote_ips
            .iter()
            .flat_map(|ip| {
                (0..TOTAL_DISTRIBUTED_REFS / num_nodes)
                    .map(|i| {
                        LocalizedResource::new(
                            ip.clone(),
                            Resource::new_file(format!("/tmp/{ip}/ref_{i}")),
                        )
                    })
                    .collect::<Vec<_>>()
            })
            .collect();

        let seq = WaitingQueueService::new(SequencerService::default(), None);
        let prov = ProvenanceService::new(node1.clone());
        let comp = ComplianceService::new(node1.clone(), ConsentService::default());

        let file = Resource::new_file("/tmp/bench".to_string());
        prov.set_references(file.clone(), refs);

        let m2m_service = M2mApiService::new(seq.clone(), prov.clone(), comp.clone());
        let p2m = P2mApiService::new(seq, prov, comp, M2mGrpc::mock()).with_enrolled_resource(
            1,
            3,
            Resource::new_process_mock(1),
            file,
        );

        rt.spawn(async move {
            Server::builder()
                .add_service(M2mServer::new(M2mHandler::new(m2m_service)))
                .add_service(P2mServer::new(P2mHandler::new(p2m)))
                .serve(addr)
                .await
                .unwrap();
        });
        std::thread::sleep(std::time::Duration::from_millis(100));

        let mut client =
            rt.block_on(proto::p2m_client::P2mClient::connect(format!("http://{addr}"))).unwrap();

        group.bench_with_input(
            BenchmarkId::from_parameter(format!("{}_nodes", num_nodes)),
            &num_nodes,
            |b, _n| {
                b.iter(|| {
                    rt.block_on(async {
                        let grant: proto::messages::Grant = client
                            .p2m_io_request(tonic::Request::new(proto::messages::IoInfo {
                                process_id: 1,
                                file_descriptor: 3,
                                flow: proto::primitives::Flow::Input as i32,
                            }))
                            .await
                            .unwrap()
                            .into_inner();

                        let _: proto::messages::Ack = client
                            .p2m_io_report(tonic::Request::new(proto::messages::IoResult {
                                process_id: 1,
                                file_descriptor: 3,
                                grant_id: grant.id,
                                result: true,
                            }))
                            .await
                            .unwrap()
                            .into_inner();
                    })
                });
            },
        );
    }
    group.finish();
}