resp-benchmark 0.1.4__tar.gz → 0.1.6__tar.gz

{resp_benchmark-0.1.4 → resp_benchmark-0.1.6}/.github/workflows/CI.yml

@@ -2,9 +2,6 @@ name: CI
 
 on:
   push:
-    branches:
-      - main
-      - master
     tags:
       - '*'
   pull_request:

{resp_benchmark-0.1.4 → resp_benchmark-0.1.6}/Cargo.lock

@@ -671,7 +671,7 @@ dependencies = [
 
 [[package]]
 name = "resp-benchmark"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "awaitgroup",
  "colored",

{resp_benchmark-0.1.4 → resp_benchmark-0.1.6}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "resp-benchmark"
-version = "0.1.4"
+version = "0.1.6"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

{resp_benchmark-0.1.4 → resp_benchmark-0.1.6}/PKG-INFO

@@ -1,18 +1,22 @@
 Metadata-Version: 2.3
 Name: resp-benchmark
-Version: 0.1.4
+Version: 0.1.6
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Dist: pydantic
 Requires-Dist: redis
 License-File: LICENSE
+Summary: resp-benchmark is a benchmark tool for testing databases that support the RESP protocol, such as Redis, Valkey, and Tair.
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 
 # resp-benchmark
 
-[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/your_username/resp-benchmark/blob/main/LICENSE)
+[![Python - Version](https://img.shields.io/badge/python-%3E%3D3.8-brightgreen)](https://www.python.org/doc/versions/)
+[![PyPI - Version](https://img.shields.io/pypi/v/resp-benchmark?color=%231772b4)](https://pypi.org/project/resp-benchmark/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dw/resp-benchmark?color=%231ba784)](https://pypi.org/project/resp-benchmark/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/tair-opensource/resp-benchmark/blob/main/LICENSE)
 
 resp-benchmark is a benchmark tool for testing databases that support the RESP protocol, 
 such as [Redis](https://github.com/redis/redis), [Valkey](https://github.com/valkey-io/valkey), 
@@ -65,17 +69,19 @@ Supported placeholders include:
 ### Benchmarking zset
 
 ```shell
-# 1. Load data
-resp-benchmark --load -n 1000000 -P 10 "ZADD {key sequence 1000} {rand 1000} {value 8}"
-# 2. Benchmark
-resp-benchmark "ZRANGEBYSCORE {key uniform 1000} {range 1000 10}"
+# Load data
+resp-benchmark --load -P 10 -c 256 -n 10007000 "ZADD {key sequence 1000} {rand 70000} {key sequence 10007}"
+# Benchmark ZSCORE
+resp-benchmark -s 10 "ZSCORE {key uniform 1000} {key uniform 10007}"
+# Benchmark ZRANGEBYSCORE
+resp-benchmark -s 10 "ZRANGEBYSCORE {key uniform 1000} {range 70000 10}"
 ```
 
 ### Benchmarking Lua Scripts
 
 ```shell
 redis-cli 'SCRIPT LOAD "return redis.call('\''SET'\'', KEYS[1], ARGV[1])"'
-resp-benchmark "EVALSHA d8f2fad9f8e86a53d2a6ebd960b33c4972cacc37 1 {key uniform 100000} {value 64}"
+resp-benchmark -s 10 "EVALSHA d8f2fad9f8e86a53d2a6ebd960b33c4972cacc37 1 {key uniform 100000} {value 64}"
 ```
 
 ## Differences with redis-benchmark

{resp_benchmark-0.1.4 → resp_benchmark-0.1.6}/README.md

@@ -1,6 +1,9 @@
 # resp-benchmark
 
-[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/your_username/resp-benchmark/blob/main/LICENSE)
+[![Python - Version](https://img.shields.io/badge/python-%3E%3D3.8-brightgreen)](https://www.python.org/doc/versions/)
+[![PyPI - Version](https://img.shields.io/pypi/v/resp-benchmark?color=%231772b4)](https://pypi.org/project/resp-benchmark/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dw/resp-benchmark?color=%231ba784)](https://pypi.org/project/resp-benchmark/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/tair-opensource/resp-benchmark/blob/main/LICENSE)
 
 resp-benchmark is a benchmark tool for testing databases that support the RESP protocol, 
 such as [Redis](https://github.com/redis/redis), [Valkey](https://github.com/valkey-io/valkey), 
@@ -53,17 +56,19 @@ Supported placeholders include:
 ### Benchmarking zset
 
 ```shell
-# 1. Load data
-resp-benchmark --load -n 1000000 -P 10 "ZADD {key sequence 1000} {rand 1000} {value 8}"
-# 2. Benchmark
-resp-benchmark "ZRANGEBYSCORE {key uniform 1000} {range 1000 10}"
+# Load data
+resp-benchmark --load -P 10 -c 256 -n 10007000 "ZADD {key sequence 1000} {rand 70000} {key sequence 10007}"
+# Benchmark ZSCORE
+resp-benchmark -s 10 "ZSCORE {key uniform 1000} {key uniform 10007}"
+# Benchmark ZRANGEBYSCORE
+resp-benchmark -s 10 "ZRANGEBYSCORE {key uniform 1000} {range 70000 10}"
 ```
 
 ### Benchmarking Lua Scripts
 
 ```shell
 redis-cli 'SCRIPT LOAD "return redis.call('\''SET'\'', KEYS[1], ARGV[1])"'
-resp-benchmark "EVALSHA d8f2fad9f8e86a53d2a6ebd960b33c4972cacc37 1 {key uniform 100000} {value 64}"
+resp-benchmark -s 10 "EVALSHA d8f2fad9f8e86a53d2a6ebd960b33c4972cacc37 1 {key uniform 100000} {value 64}"
 ```
 
 ## Differences with redis-benchmark

{resp_benchmark-0.1.4 → resp_benchmark-0.1.6}/pyproject.toml

@@ -4,6 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "resp-benchmark"
+description = "resp-benchmark is a benchmark tool for testing databases that support the RESP protocol, such as Redis, Valkey, and Tair."
 requires-python = ">=3.8"
 classifiers = [
     "Programming Language :: Rust",

resp_benchmark-0.1.6/python/resp_benchmark/__init__.py

@@ -0,0 +1 @@
+from .wrapper import Benchmark, Result

{resp_benchmark-0.1.4 → resp_benchmark-0.1.6}/python/resp_benchmark/cli.py

@@ -14,10 +14,10 @@ def parse_args():
     parser.add_argument("-p", metavar="port", type=int, default=6379, help="Server port (default 6379)")
     parser.add_argument("-u", metavar="username", type=str, default="", help="Used to send ACL style \"AUTH username pass\". Needs -a.")
     parser.add_argument("-a", metavar="password", type=str, default="", help="Password for Redis Auth")
-    parser.add_argument("-c", metavar="clients", type=int, default=50, help="Number of parallel connections (default 50)")
-    parser.add_argument("--cores", type=str, default=f"", help="Comma-separated list of CPU cores to use.")
-    parser.add_argument("--cluster", action="store_true", help="Enable cluster mode.")
-    parser.add_argument("-n", metavar="requests", type=int, default=100000, help="Total number of requests (default 100000), 0 for unlimited.")
+    parser.add_argument("-c", metavar="clients", type=int, default=0, help="Number of parallel connections (0 for auto, default: 0)")
+    parser.add_argument("--cores", type=str, default=f"", help="Comma-separated list of CPU cores to use (default all)")
+    parser.add_argument("--cluster", action="store_true", help="Use cluster mode (default false)")
+    parser.add_argument("-n", metavar="requests", type=int, default=0, help="Total number of requests (default 0), 0 for unlimited.")
     parser.add_argument("-s", metavar="seconds", type=int, default=0, help="Total time in seconds (default 0), 0 for unlimited.")
     parser.add_argument("-P", metavar="pipeline", type=int, default=1, help="Pipeline <numreq> requests. Default 1 (no pipeline).")
     # parser.add_argument("--tls", action="store_true", help="Use TLS for connection (default false)")

{resp_benchmark-0.1.4 → resp_benchmark-0.1.6}/python/resp_benchmark/wrapper.py

@@ -8,23 +8,6 @@ import redis
 from .cores import parse_cores_string
 
 
-@dataclass
-class ResultPoint:
-    """
-    Represents a single data point in benchmark results.
-
-    Attributes:
-        timestamp_second (int): Unix timestamp in seconds.
-        qps (float): Queries per second at this timestamp.
-        avg_latency_ms (float): Average latency in milliseconds at this timestamp.
-        p99_latency_ms (float): 99th percentile latency in milliseconds at this timestamp.
-    """
-    timestamp_second: int
-    qps: float
-    avg_latency_ms: float
-    p99_latency_ms: float
-
-
 @dataclass
 class Result:
     """
@@ -34,12 +17,10 @@ class Result:
         qps (float): Average queries per second.
         avg_latency_ms (float): Average latency in milliseconds.
         p99_latency_ms (float): 99th percentile latency in milliseconds.
-        per_second_data (List[ResultPoint]): List of per-second data points.
     """
     qps: float
     avg_latency_ms: float
     p99_latency_ms: float
-    per_second_data: List[ResultPoint]
 
 
 class Benchmark:
@@ -83,9 +64,9 @@ class Benchmark:
     def bench(
             self,
             command: str,
-            connections: int = 32,
+            connections: int = 0,
             pipeline: int = 1,
-            count: int = 100000,
+            count: int = 0,
             seconds: int = 0,
             quiet: bool = False,
     ) -> Result:
@@ -125,15 +106,6 @@ class Benchmark:
             qps=ret.qps,
             avg_latency_ms=ret.avg_latency_ms,
             p99_latency_ms=ret.p99_latency_ms,
-            per_second_data=[
-                ResultPoint(
-                    timestamp_second=point.timestamp_second,
-                    qps=point.qps,
-                    avg_latency_ms=point.avg_latency_ms,
-                    p99_latency_ms=point.p99_latency_ms,
-                )
-                for point in ret.per_second_data
-            ],
         )
 
         return result

{resp_benchmark-0.1.4 → resp_benchmark-0.1.6}/src/auto_connection.rs

@@ -1,6 +1,7 @@
 use std::sync::atomic::AtomicU64;
 use std::sync::Arc;
 use tokio::sync::Notify;
+use crate::histogram::Histogram;
 
 const MAX_CONN: u64 = if cfg!(target_os = "macos") { 64 } else { 1024 }; // 1024 is enough for most cases
 
@@ -104,11 +105,12 @@ impl AutoConnection {
     pub fn active_conn(&self) -> u64 {
         self.limiters.iter().map(|limiter| limiter.get_active_conn()).sum()
     }
+    #[allow(dead_code)]
     pub fn target_conn(&self) -> u64 {
         self.limiters.iter().map(|limiter| limiter.get_target_conn()).sum()
     }
 
-    pub fn adjust(&mut self, cnt: u64) {
+    pub fn adjust(&mut self, h: &Histogram) {
         if self.ready {
             return;
         }
@@ -117,12 +119,12 @@ impl AutoConnection {
         if elapsed < 0.5 {
             return;
         }
-        let qps = (cnt - self.last_cnt) as f64 / elapsed;
+        let qps = (h.cnt() - self.last_cnt) as f64 / elapsed;
         let need_add_conn;
-        if qps >= self.last_qps * 1.5 || elapsed >= 3f64 {
+        if qps >= self.last_qps * 2.0 || elapsed >= 3f64 {
             if self.last_qps == 0.0 {
                 need_add_conn = 1; // at least 1 connection
-            } else if qps > self.last_qps * 1.1 {
+            } else if qps > self.last_qps * 1.3 {
                 need_add_conn = self.active_conn();
             } else {
                 self.ready = true;
@@ -136,7 +138,7 @@ impl AutoConnection {
             self.inx = (self.inx + 1) % self.limiters.len();
         }
         self.last_qps = qps;
-        self.last_cnt = cnt;
+        self.last_cnt = h.cnt();
         self.instant = std::time::Instant::now();
         return;
     }

{resp_benchmark-0.1.4 → resp_benchmark-0.1.6}/src/bench.rs

@@ -46,7 +46,11 @@ async fn run_commands_on_single_thread(limiter: Arc<ConnLimiter>, config: Client
                 // prepare pipeline
                 let mut p = Vec::new();
                 for _ in 0..pipeline_cnt {
-                    p.push(cmd.gen_cmd());
+                    if context.is_loading {
+                        p.push(cmd.gen_cmd_with_lock());
+                    } else {
+                        p.push(cmd.gen_cmd());
+                    }
                 }
                 let instant = std::time::Instant::now();
                 client.run_commands(p).await;
@@ -60,7 +64,7 @@ async fn run_commands_on_single_thread(limiter: Arc<ConnLimiter>, config: Client
     local.await;
 }
 
-fn wait_finish(case: &Case, mut auto_connection: AutoConnection, mut context: SharedContext, mut wg: WaitGroup, load: bool, quiet: bool) -> BenchmarkResult {
+fn wait_finish(case: &Case, mut auto_connection: AutoConnection, mut context: SharedContext, mut wg: WaitGroup, quiet: bool) -> BenchmarkResult {
     let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
     let mut result = BenchmarkResult::default();
 
@@ -88,16 +92,15 @@ fn wait_finish(case: &Case, mut auto_connection: AutoConnection, mut context: Sh
             {
                 let cnt = histogram.cnt();
                 let qps = (cnt - log_last_cnt) as f64 / log_instance.elapsed().as_secs_f64();
-                let active_conn: u64 = auto_connection.active_conn();
-                let target_conn: u64 = auto_connection.target_conn();
+                let conn: u64 = auto_connection.active_conn();
                 if auto_connection.ready {
                     result.qps = (cnt - overall_cnt_overhead) as f64 / overall_time.elapsed().as_secs_f64();
                 }
                 if !quiet {
-                    if load {
-                        print!("\r\x1B[2KData loading qps: {:.0}, {:.2}%", qps, histogram.cnt() as f64 / case.count as f64 * 100f64);
+                    if context.is_loading {
+                        println!("\x1B[F\x1B[2KData loading qps: {:.0}, {:.2}%", qps, histogram.cnt() as f64 / case.count as f64 * 100f64);
                     } else {
-                        print!("\r\x1B[2Kqps: {:.0}(overall {:.0}), active_conn: {}, target_conn: {}, {}", qps, result.qps, active_conn, target_conn, histogram);
+                        println!("\x1B[F\x1B[2Kqps: {:.0}(overall {:.0}), conn: {}, {}", qps, result.qps, conn, histogram);
                     }
                 }
                 std::io::stdout().flush().unwrap();
@@ -105,8 +108,7 @@ fn wait_finish(case: &Case, mut auto_connection: AutoConnection, mut context: Sh
                 log_instance = std::time::Instant::now();
             }
             if !auto_connection.ready {
-                let cnt = histogram.cnt();
-                auto_connection.adjust(cnt);
+                auto_connection.adjust(&histogram);
                 if auto_connection.ready {
                     overall_cnt_overhead = histogram.cnt();
                     overall_time = std::time::Instant::now();
@@ -114,11 +116,11 @@ fn wait_finish(case: &Case, mut auto_connection: AutoConnection, mut context: Sh
                 }
             }
         }
-        let active_conn: u64 = auto_connection.active_conn();
-        if load {
-            print!("\r\x1B[2KData loaded, qps: {:.0}, time elapsed: {:.2}s\n", result.qps, overall_time.elapsed().as_secs_f64());
+        let conn: u64 = auto_connection.active_conn();
+        if context.is_loading {
+            println!("\x1B[F\x1B[2KData loaded, qps: {:.0}, time elapsed: {:.2}s\n", result.qps, overall_time.elapsed().as_secs_f64());
         } else {
-            print!("\r\x1B[2Kqps: {:.0}, conn: {}, {}\n", result.qps, active_conn, histogram)
+            println!("\x1B[F\x1B[2Kqps: {:.0}, conn: {}, {}\n", result.qps, conn, histogram)
         };
         result.avg_latency_ms = histogram.avg() as f64 / 1_000.0;
         result.p99_latency_ms = histogram.percentile(0.99) as f64 / 1_000.0;
@@ -141,7 +143,7 @@ pub fn do_benchmark(client_config: ClientConfig, cores: Vec<u16>, case: Case, lo
     let mut thread_handlers = Vec::new();
     let wg = WaitGroup::new();
     let core_ids = core_affinity::get_core_ids().unwrap();
-    let context = SharedContext::new(case.count, case.seconds);
+    let context = SharedContext::new(case.count, case.seconds, load);
     for inx in 0..cores.len() {
         let client_config = client_config.clone();
         let case = case.clone();
@@ -161,7 +163,7 @@ pub fn do_benchmark(client_config: ClientConfig, cores: Vec<u16>, case: Case, lo
     }
 
     // log thread
-    let result = wait_finish(&case, auto_connection, context, wg, load, quiet);
+    let result = wait_finish(&case, auto_connection, context, wg, quiet);
 
     // join all threads
     for thread_handler in thread_handlers {

{resp_benchmark-0.1.4 → resp_benchmark-0.1.6}/src/command/mod.rs

@@ -33,22 +33,30 @@ impl Command {
     }
     pub fn gen_cmd(&mut self) -> redis::Cmd {
         let mut cmd = redis::Cmd::new();
+        let mut cmd_str = String::new();
         for ph in self.argv.iter_mut() {
             for arg in ph.gen() {
-                cmd.arg(arg);
+                cmd_str.push_str(&arg);
             }
         }
+        for word in cmd_str.split_whitespace() {
+            cmd.arg(word);
+        }
         cmd
     }
     #[allow(dead_code)]
     pub fn gen_cmd_with_lock(&mut self) -> redis::Cmd {
-        let mut cmd = redis::Cmd::new();
         let _lock = self.lock.lock().unwrap();
+        let mut cmd = redis::Cmd::new();
+        let mut cmd_str = String::new();
         for ph in self.argv.iter_mut() {
             for arg in ph.gen() {
-                cmd.arg(arg);
+                cmd_str.push_str(&arg);
             }
         }
+        for word in cmd_str.split_whitespace() {
+            cmd.arg(word);
+        }
         cmd
     }
     pub fn to_string(&self) -> String {

{resp_benchmark-0.1.4 → resp_benchmark-0.1.6}/src/command/parser.rs

@@ -3,7 +3,6 @@ use nom::{
     sequence::delimited,
     branch::alt,
     bytes::complete::{is_not, tag},
-    character::complete::multispace0,
     multi::many0,
     combinator::{map, all_consuming},
 };
@@ -13,16 +12,15 @@ fn parse_string(input: &str) -> IResult<&str, PlaceholderEnum> {
     let s = alt((
         delimited(tag("\""), is_not("\""), tag("\"")),
         delimited(tag("\'"), is_not("\'"), tag("\'")),
-        delimited(multispace0, is_not("{ "), multispace0)
-        ));
+        is_not("{")
+    ));
     map(s, PlaceholderEnum::new_string)(input)
 }
 
 
 fn parse_placeholder(input: &str) -> IResult<&str, PlaceholderEnum> {
     let inner = delimited(tag("{"), is_not("}"), tag("}"));
-    let eat_whitespace = delimited(multispace0, inner, multispace0);
-    map(eat_whitespace, PlaceholderEnum::new)(input)
+    map(inner, PlaceholderEnum::new)(input)
 }
 
 
@@ -36,7 +34,7 @@ mod tests {
 
     #[test]
     fn test_root() {
-        let (nm, args) = match parse_all("aa {key sequence 100} bbb") {
+        let (nm, args) = match parse_all("aa test_{key sequence 100} bbb") {
             Ok((nm, args)) => (nm, args),
             Err(e) => {
                 println!("Error: {:?}", e);

{resp_benchmark-0.1.4 → resp_benchmark-0.1.6}/src/lib.rs

@@ -18,14 +18,6 @@ fn _resp_benchmark_rust_lib(m: &Bound<'_, PyModule>) -> PyResult<()> {
     Ok(())
 }
 
-#[pyclass]
-#[derive(Clone)]
-struct ResultPoint {
-    #[pyo3(get, set)] pub timestamp_second: i64,
-    #[pyo3(get, set)] pub qps: f64,
-    #[pyo3(get, set)] pub avg_latency_ms: f64,
-    #[pyo3(get, set)] pub p99_latency_ms: f64,
-}
 
 #[pyclass]
 #[derive(Default)]
@@ -33,7 +25,6 @@ struct BenchmarkResult {
     #[pyo3(get, set)] pub qps: f64,
     #[pyo3(get, set)] pub avg_latency_ms: f64,
     #[pyo3(get, set)] pub p99_latency_ms: f64,
-    #[pyo3(get, set)] pub per_second_data: Vec<ResultPoint>,
 }
 
 #[pyfunction]
@@ -56,10 +47,8 @@ fn benchmark(
 ) -> PyResult<BenchmarkResult> {
     assert!(cores.len() > 0);
     if load {
-        assert_ne!(connections, 0);
-        assert_ne!(count, 0);
+        assert_ne!(count, 0, "count must be greater than 0");
     }
-    assert!(count != 0 || seconds != 0);
 
     let _ = ctrlc::set_handler(move || {
         std::process::exit(0);

{resp_benchmark-0.1.4 → resp_benchmark-0.1.6}/src/shared_context.rs

@@ -8,6 +8,7 @@ use std::time::Instant;
 
 #[derive(Clone)]
 pub struct SharedContext {
+    pub is_loading: bool,
     // limit by max_count
     current_count: Arc<AtomicU64>,
     max_count: u64,
@@ -24,8 +25,9 @@ pub struct SharedContext {
 }
 
 impl SharedContext {
-    pub fn new(max_count: u64, max_seconds: u64) -> Self {
+    pub fn new(max_count: u64, max_seconds: u64, is_loading: bool) -> Self {
         SharedContext {
+            is_loading,
             current_count: Arc::new(AtomicU64::new(0)),
             max_count,
             instant: Arc::new(RwLock::new(None)),

resp_benchmark-0.1.4/python/resp_benchmark/__init__.py

@@ -1 +0,0 @@
-from .wrapper import Benchmark, Result, ResultPoint