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

{resp_benchmark-0.1.4 → resp_benchmark-0.1.5}/.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.5}/Cargo.lock

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

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

@@ -1,6 +1,6 @@
 [package]
 name = "resp-benchmark"
-version = "0.1.4"
+version = "0.1.5"
 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.5}/PKG-INFO

@@ -1,18 +1,22 @@
 Metadata-Version: 2.3
 Name: resp-benchmark
-Version: 0.1.4
+Version: 0.1.5
 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.5}/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.5}/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.5/python/resp_benchmark/__init__.py

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

{resp_benchmark-0.1.4 → resp_benchmark-0.1.5}/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.5}/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.5}/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.5}/src/bench.rs

@@ -88,8 +88,7 @@ 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();
                 }
@@ -97,7 +96,7 @@ fn wait_finish(case: &Case, mut auto_connection: AutoConnection, mut context: Sh
                     if load {
                         print!("\r\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);
+                        print!("\r\x1B[2Kqps: {:.0}(overall {:.0}), conn: {}, {}", qps, result.qps, conn, histogram);
                     }
                 }
                 std::io::stdout().flush().unwrap();
@@ -105,8 +104,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 +112,11 @@ fn wait_finish(case: &Case, mut auto_connection: AutoConnection, mut context: Sh
                 }
             }
         }
-        let active_conn: u64 = auto_connection.active_conn();
+        let 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());
         } else {
-            print!("\r\x1B[2Kqps: {:.0}, conn: {}, {}\n", result.qps, active_conn, histogram)
+            print!("\r\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;

{resp_benchmark-0.1.4 → resp_benchmark-0.1.5}/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/python/resp_benchmark/__init__.py

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