Remove ParamsSer and extend benchmarking

Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>
paritytech · lexnv · Sep 6, 2022 · Aug 24, 2022 · Aug 24, 2022 · Aug 24, 2022
commit 83d94c60ab13e3f9e4dce49342aa1cab7789ced4
@@ -6,10 +6,10 @@ 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::{ArrayParamsBuilder, BatchRequestBuilder, EmptyParams};
+use jsonrpsee::core::params::{ArrayParamsBuilder, BatchRequestBuilder, EmptyParams, ObjectParamsBuilder};
 use jsonrpsee::core::traits::ToRpcParams;
 use jsonrpsee::http_client::HeaderMap;
-use jsonrpsee::types::{Id, ParamsSer, RequestSer};
+use jsonrpsee::types::{Id, RequestSer};
 use pprof::criterion::{Output, PProfProfiler};
 use tokio::runtime::Runtime as TokioRuntime;
 
@@ -65,21 +65,17 @@ fn v2_serialize(req: RequestSer<'_>) -> String {
 }
 
 pub fn jsonrpsee_types_v2(crit: &mut Criterion) {
-	// Construct the serialized request using the `ParamsSer` directly.
-	crit.bench_function("jsonrpsee_types_baseline_params", |b| {
+	// Construct the serialized array request using the `RawValue` directly.
+	crit.bench_function("jsonrpsee_types_array_params_baseline", |b| {
 		b.iter(|| {
-			let params = &[1_u64.into(), 2_u32.into()];
-			let params = ParamsSer::ArrayRef(params);
-			let params = serde_json::to_string(&params).unwrap();
-			let params = serde_json::value::RawValue::from_string(params).unwrap();
+			let params = serde_json::value::RawValue::from_string("[1, 2]".to_string()).unwrap();
 
 			let request = RequestSer::new(&Id::Number(0), "say_hello", Some(params));
 			v2_serialize(request);
 		})
 	});
-
 	// Construct the serialized request using the `ArrayParamsBuilder`.
-	crit.bench_function("jsonrpsee_types_unnamed_params", |b| {
+	crit.bench_function("jsonrpsee_types_array_params", |b| {
 		b.iter(|| {
 			let mut builder = ArrayParamsBuilder::new();
 			builder.insert(1u64).unwrap();
@@ -89,6 +85,26 @@ pub fn jsonrpsee_types_v2(crit: &mut Criterion) {
 			v2_serialize(request);
 		})
 	});
+
+	// Construct the serialized object request using the `RawValue` directly.
+	crit.bench_function("jsonrpsee_types_object_params_baseline", |b| {
+		b.iter(|| {
+			let params = serde_json::value::RawValue::from_string(r#"{"key": 1}"#.to_string()).unwrap();
+
+			let request = RequestSer::new(&Id::Number(0), "say_hello", Some(params));
+			v2_serialize(request);
+		})
+	});
+	// Construct the serialized request using the `ObjectParamsBuilder`.
+	crit.bench_function("jsonrpsee_types_object_params", |b| {
+		b.iter(|| {
+			let mut builder = ObjectParamsBuilder::new();
+			builder.insert("key", 1u32).unwrap();
+			let params = builder.build().to_rpc_params().expect("Valid params");
+			let request = RequestSer::new(&Id::Number(0), "say_hello", params);
+			v2_serialize(request);
+		})
+	});
 }
 
 trait RequestBencher {

@@ -43,7 +43,7 @@ pub mod response;
 pub mod error;
 
 pub use error::{ErrorObject, ErrorObjectOwned, ErrorResponse, SubscriptionEmptyError, SubscriptionResult};
-pub use params::{Id, Params, ParamsSequence, ParamsSer, SubscriptionId, TwoPointZero};
+pub use params::{Id, Params, ParamsSequence, SubscriptionId, TwoPointZero};
 pub use request::{InvalidRequest, Notification, NotificationSer, Request, RequestSer};
 pub use response::{Response, SubscriptionPayload, SubscriptionResponse};
 

@@ -30,7 +30,6 @@
 use std::fmt;
 
 use crate::error::CallError;
-use alloc::collections::BTreeMap;
 use anyhow::anyhow;
 use beef::Cow;
 use serde::de::{self, Deserializer, Unexpected, Visitor};
@@ -260,40 +259,6 @@ impl<'a> ParamsSequence<'a> {
 	}
 }
 
-/// [Serializable JSON-RPC parameters](https://www.jsonrpc.org/specification#parameter_structures)
-///
-/// If your type implements `Into<JsonValue>`, call that in favor of `serde_json::to:value` to
-/// construct the parameters. Because `serde_json::to_value` serializes the type which allocates
-/// whereas `Into<JsonValue>` doesn't in most cases.
-#[derive(Serialize, Debug, Clone)]
-#[serde(untagged)]
-pub enum ParamsSer<'a> {
-	/// Positional params (heap allocated).
-	Array(Vec<JsonValue>),
-	/// Positional params (slice).
-	ArrayRef(&'a [JsonValue]),
-	/// Params by name.
-	Map(BTreeMap<&'a str, JsonValue>),
-}
-
-impl<'a> From<BTreeMap<&'a str, JsonValue>> for ParamsSer<'a> {
-	fn from(map: BTreeMap<&'a str, JsonValue>) -> Self {
-		Self::Map(map)
-	}
-}
-
-impl<'a> From<Vec<JsonValue>> for ParamsSer<'a> {
-	fn from(arr: Vec<JsonValue>) -> Self {
-		Self::Array(arr)
-	}
-}
-
-impl<'a> From<&'a [JsonValue]> for ParamsSer<'a> {
-	fn from(slice: &'a [JsonValue]) -> Self {
-		Self::ArrayRef(slice)
-	}
-}
-
 /// Id of a subscription, communicated by the server.
 #[derive(Debug, PartialEq, Clone, Hash, Eq, Deserialize, Serialize)]
 #[serde(deny_unknown_fields)]
@@ -410,7 +375,7 @@ impl<'a> Id<'a> {
 
 #[cfg(test)]
 mod test {
-	use super::{Cow, Id, JsonValue, Params, ParamsSer, SubscriptionId, TwoPointZero};
+	use super::{Cow, Id, JsonValue, Params, SubscriptionId, TwoPointZero};
 	use crate::response::SubscriptionPayload;
 
 	#[test]
@@ -449,23 +414,6 @@ mod test {
 		assert_eq!(serialized, r#"[null,0,2,3,"\"3","test"]"#);
 	}
 
-	#[test]
-	fn params_serialize() {
-		let test_vector = &[
-			("[]", ParamsSer::Array(serde_json::from_str("[]").unwrap())),
-			("[42,23]", ParamsSer::Array(serde_json::from_str("[42,23]").unwrap())),
-			(
-				r#"{"a":42,"b":null,"c":"aa"}"#,
-				ParamsSer::Map(serde_json::from_str(r#"{"a":42,"b":null,"c":"aa"}"#).unwrap()),
-			),
-		];
-
-		for (initial_ser, params) in test_vector {
-			let serialized = serde_json::to_string(params).unwrap();
-			assert_eq!(&serialized, initial_ser);
-		}
-	}
-
 	#[test]
 	fn params_parse() {
 		let none = Params::new(None);