Skip to content
GitLab
Unverified Commit 8431ff7f authored by Niklas Adolfsson's avatar Niklas Adolfsson Committed by GitHub
Browse files

fix(benches): run benches against fixed client version (#890) 

* fix(jsonrpsee): add `types` to server feature

* fix(benches): benches against fixed client version

* address grumbles
parent d390823a
Pipeline #221297 passed with stages
in 53 minutes and 42 seconds
Hide whitespace changes
Inline Side-by-side
.github/workflows/benchmarks_gitlab.yml
View file @ 8431ff7f
......@@ -2,7 +2,7 @@ name: Benchmarks gitlab
on:
schedule:
- cron: "0 14 * * *"
- cron: "0 5 * * *"
jobs:
bench:
......
benches/Cargo.toml
View file @ 8431ff7f
......@@ -12,7 +12,8 @@ pprof = { version = "0.10", features = ["flamegraph", "criterion"] }
criterion = { version = "0.3", features = ["async_tokio", "html_reports"] }
futures-channel = "0.3.15"
futures-util = "0.3.15"
jsonrpsee = { path = "../jsonrpsee", features = ["full"] }
jsonrpsee = { path = "../jsonrpsee", features = ["server"] }
jsonrpsee_v0_15 = { package = "jsonrpsee", version = "=0.15.1", features = ["http-client", "ws-client", "client-ws-transport"] }
jsonrpc-ws-server = { version = "18.0.0", optional = true }
jsonrpc-http-server = { version = "18.0.0", optional = true }
jsonrpc-pubsub = { version = "18.0.0", optional = true }
......
benches/bench.rs
View file @ 8431ff7f
use std::sync::Arc;
use std::time::Duration;
use crate::helpers::{ws_handshake, KIB};
use criterion::*;
use futures_util::future::{join_all, FutureExt};
use futures_util::stream::FuturesUnordered;
use helpers::{http_client, ws_client, SUB_METHOD_NAME, UNSUB_METHOD_NAME};
use jsonrpsee::core::client::{ClientT, SubscriptionClientT};
use jsonrpsee::core::params::{ArrayParams, BatchRequestBuilder, ObjectParams};
use jsonrpsee::core::traits::ToRpcParams;
use jsonrpsee::http_client::HeaderMap;
use helpers::fixed_client::{http_client, ws_client, ws_handshake, ClientT, HeaderMap, SubscriptionClientT};
use helpers::{KIB, SUB_METHOD_NAME, UNSUB_METHOD_NAME};
use jsonrpsee::types::{Id, RequestSer};
use pprof::criterion::{Output, PProfProfiler};
use tokio::runtime::Runtime as TokioRuntime;
......@@ -121,6 +117,8 @@ pub fn jsonrpsee_types_v2(crit: &mut Criterion) {
});
// Construct the serialized request using the `ArrayParams`.
crit.bench_function("jsonrpsee_types_array_params", |b| {
use jsonrpsee::core::{params::ArrayParams, traits::ToRpcParams};
b.iter(|| {
let mut builder = ArrayParams::new();
builder.insert(1u64).unwrap();
......@@ -142,6 +140,8 @@ pub fn jsonrpsee_types_v2(crit: &mut Criterion) {
});
// Construct the serialized request using the `ObjectParams`.
crit.bench_function("jsonrpsee_types_object_params", |b| {
use jsonrpsee::core::{params::ObjectParams, traits::ToRpcParams};
b.iter(|| {
let mut builder = ObjectParams::new();
builder.insert("key", 1u32).unwrap();
......@@ -239,7 +239,7 @@ fn round_trip(rt: &TokioRuntime, crit: &mut Criterion, client: Arc<impl ClientT>
let bench_name = format!("{}/{}", name, method);
crit.bench_function(&request.group_name(&bench_name), |b| {
b.to_async(rt).iter(|| async {
black_box(client.request::<String, ArrayParams>(method, ArrayParams::new()).await.unwrap());
black_box(client.request::<String>(method, None).await.unwrap());
})
});
}
......@@ -249,12 +249,7 @@ fn sub_round_trip(rt: &TokioRuntime, crit: &mut Criterion, client: Arc<impl Subs
let mut group = crit.benchmark_group(name);
group.bench_function("subscribe", |b| {
b.to_async(rt).iter_with_large_drop(|| async {
black_box(
client
.subscribe::<String, ArrayParams>(SUB_METHOD_NAME, ArrayParams::new(), UNSUB_METHOD_NAME)
.await
.unwrap(),
);
black_box(client.subscribe::<String>(SUB_METHOD_NAME, None, UNSUB_METHOD_NAME).await.unwrap());
})
});
group.bench_function("subscribe_response", |b| {
......@@ -264,10 +259,7 @@ fn sub_round_trip(rt: &TokioRuntime, crit: &mut Criterion, client: Arc<impl Subs
// runtime context and simply calling `block_on` here will cause the code to panic.
tokio::task::block_in_place(|| {
tokio::runtime::Handle::current().block_on(async {
client
.subscribe::<String, ArrayParams>(SUB_METHOD_NAME, ArrayParams::new(), UNSUB_METHOD_NAME)
.await
.unwrap()
client.subscribe::<String>(SUB_METHOD_NAME, None, UNSUB_METHOD_NAME).await.unwrap()
})
})
},
......@@ -284,10 +276,7 @@ fn sub_round_trip(rt: &TokioRuntime, crit: &mut Criterion, client: Arc<impl Subs
b.iter_with_setup(
|| {
rt.block_on(async {
client
.subscribe::<String, ArrayParams>(SUB_METHOD_NAME, ArrayParams::new(), UNSUB_METHOD_NAME)
.await
.unwrap()
client.subscribe::<String>(SUB_METHOD_NAME, None, UNSUB_METHOD_NAME).await.unwrap()
})
},
|sub| {
......@@ -314,10 +303,8 @@ fn batch_round_trip(
let bench_name = format!("{}/{}", name, fast_call);
let mut group = crit.benchmark_group(request.group_name(&bench_name));
for batch_size in [2, 5, 10, 50, 100usize].iter() {
let mut batch = BatchRequestBuilder::new();
for _ in 0..*batch_size {
batch.insert(fast_call, ArrayParams::new()).unwrap();
}
let batch = vec![(fast_call, None); *batch_size];
group.throughput(Throughput::Elements(*batch_size as u64));
group.bench_with_input(BenchmarkId::from_parameter(batch_size), batch_size, |b, _| {
b.to_async(rt).iter(|| async { client.batch_request::<String>(batch.clone()).await.unwrap() })
......@@ -362,7 +349,7 @@ fn ws_concurrent_conn_calls(
let futs = FuturesUnordered::new();
for _ in 0..10 {
futs.push(client.request::<String, ArrayParams>(fast_call, ArrayParams::new()));
futs.push(client.request::<String>(fast_call, None));
}
join_all(futs).await;
......@@ -409,17 +396,13 @@ fn ws_concurrent_conn_subs(
let futs = FuturesUnordered::new();
for _ in 0..10 {
let fut = client
.subscribe::<String, ArrayParams>(
SUB_METHOD_NAME,
ArrayParams::new(),
UNSUB_METHOD_NAME,
)
.then(|sub| async move {
let fut = client.subscribe::<String>(SUB_METHOD_NAME, None, UNSUB_METHOD_NAME).then(
|sub| async move {
let mut s = sub.unwrap();
s.next().await.unwrap().unwrap()
});
},
);
futs.push(Box::pin(fut));
}
......@@ -456,7 +439,7 @@ fn http_concurrent_conn_calls(
|clients| async {
let tasks = clients.map(|client| {
rt.spawn(async move {
client.request::<String, ArrayParams>(fast_call, ArrayParams::new()).await.unwrap();
client.request::<String>(fast_call, None).await.unwrap();
})
});
join_all(tasks).await;
......@@ -489,7 +472,7 @@ fn http_custom_headers_round_trip(
crit.bench_function(&request.group_name(&bench_name), |b| {
b.to_async(rt).iter(|| async {
black_box(client.request::<String, ArrayParams>(fast_call, ArrayParams::new()).await.unwrap());
black_box(client.request::<String>(fast_call, None).await.unwrap());
})
});
}
......
benches/helpers.rs
View file @ 8431ff7f
use std::time::Duration;
use jsonrpsee::client_transport::ws::{Uri, WsTransportClientBuilder};
use jsonrpsee::http_client::{HeaderMap, HttpClient, HttpClientBuilder};
use jsonrpsee::ws_client::{WsClient, WsClientBuilder};
pub(crate) const SYNC_FAST_CALL: &str = "fast_call";
pub(crate) const ASYNC_FAST_CALL: &str = "fast_call_async";
pub(crate) const SYNC_MEM_CALL: &str = "memory_intense";
......@@ -190,25 +186,40 @@ fn gen_rpc_module() -> jsonrpsee::RpcModule<()> {
module
}
pub(crate) fn http_client(url: &str, headers: HeaderMap) -> HttpClient {
HttpClientBuilder::default()
.max_request_body_size(u32::MAX)
.max_concurrent_requests(1024 * 1024)
.set_headers(headers)
.build(url)
.unwrap()
}
pub(crate) async fn ws_client(url: &str) -> WsClient {
WsClientBuilder::default()
.max_request_body_size(u32::MAX)
.max_concurrent_requests(1024 * 1024)
.build(url)
.await
.unwrap()
}
pub(crate) async fn ws_handshake(url: &str, headers: HeaderMap) {
let uri: Uri = url.parse().unwrap();
WsTransportClientBuilder::default().max_request_body_size(u32::MAX).set_headers(headers).build(uri).await.unwrap();
pub mod fixed_client {
use jsonrpsee_v0_15::client_transport::ws::{Uri, WsTransportClientBuilder};
use jsonrpsee_v0_15::http_client::{HttpClient, HttpClientBuilder};
use jsonrpsee_v0_15::ws_client::{WsClient, WsClientBuilder};
pub use jsonrpsee_v0_15::core::client::{ClientT, SubscriptionClientT};
pub use jsonrpsee_v0_15::http_client::HeaderMap;
pub use jsonrpsee_v0_15::rpc_params;
pub(crate) fn http_client(url: &str, headers: HeaderMap) -> HttpClient {
HttpClientBuilder::default()
.max_request_body_size(u32::MAX)
.max_concurrent_requests(1024 * 1024)
.set_headers(headers)
.build(url)
.unwrap()
}
pub(crate) async fn ws_client(url: &str) -> WsClient {
WsClientBuilder::default()
.max_request_body_size(u32::MAX)
.max_concurrent_requests(1024 * 1024)
.build(url)
.await
.unwrap()
}
pub(crate) async fn ws_handshake(url: &str, headers: HeaderMap) {
let uri: Uri = url.parse().unwrap();
WsTransportClientBuilder::default()
.max_request_body_size(u32::MAX)
.set_headers(headers)
.build(uri)
.await
.unwrap();
}
}
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment