redis-benchmarks-specification 0.2.19__tar.gz → 0.2.20__tar.gz

{redis_benchmarks_specification-0.2.19 → redis_benchmarks_specification-0.2.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis-benchmarks-specification
-Version: 0.2.19
+Version: 0.2.20
 Summary: The Redis benchmarks specification describes the cross-language/tools requirements and expectations to foster performance and observability standards around redis related technologies. Members from both industry and academia, including organizations and individuals are encouraged to contribute.
 Author: filipecosta90
 Author-email: filipecosta.90@gmail.com

{redis_benchmarks_specification-0.2.19 → redis_benchmarks_specification-0.2.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "redis-benchmarks-specification"
-version = "0.2.19"
+version = "0.2.20"
 description = "The Redis benchmarks specification describes the cross-language/tools requirements and expectations to foster performance and observability standards around redis related technologies. Members from both industry and academia, including organizations and individuals are encouraged to contribute."
 authors = ["filipecosta90 <filipecosta.90@gmail.com>","Redis Performance Group <performance@redis.com>"]
 readme = "Readme.md"

{redis_benchmarks_specification-0.2.19 → redis_benchmarks_specification-0.2.20}/redis_benchmarks_specification/__common__/timeseries.py

@@ -139,9 +139,13 @@ def extract_results_table(
 
                 # Debug logging for JSON path resolution
                 if "ALL STATS" in metric_jsonpath or "ALL_STATS" in metric_jsonpath:
-                    logging.info(f"DEBUG: Found {len(find_res)} results for JSONPath '{metric_jsonpath}'")
+                    logging.info(
+                        f"DEBUG: Found {len(find_res)} results for JSONPath '{metric_jsonpath}'"
+                    )
                     for i, result in enumerate(find_res):
-                        logging.info(f"  Result {i}: path='{result.path}', value={result.value}, context='{result.context.path}'")
+                        logging.info(
+                            f"  Result {i}: path='{result.path}', value={result.value}, context='{result.context.path}'"
+                        )
 
                 for metric in find_res:
                     metric_name = str(metric.path)
@@ -209,11 +213,17 @@ def extract_results_table(
                 )
                 # Debug logging for missing metrics - show available keys
                 if "ALL STATS" in str(jsonpath) or "ALL_STATS" in str(jsonpath):
-                    logging.info(f"DEBUG: Available top-level keys in results_dict: {list(results_dict.keys())}")
+                    logging.info(
+                        f"DEBUG: Available top-level keys in results_dict: {list(results_dict.keys())}"
+                    )
                     if "ALL STATS" in results_dict:
-                        logging.info(f"DEBUG: Keys in 'ALL STATS': {list(results_dict['ALL STATS'].keys())}")
+                        logging.info(
+                            f"DEBUG: Keys in 'ALL STATS': {list(results_dict['ALL STATS'].keys())}"
+                        )
                     if "ALL_STATS" in results_dict:
-                        logging.info(f"DEBUG: Keys in 'ALL_STATS': {list(results_dict['ALL_STATS'].keys())}")
+                        logging.info(
+                            f"DEBUG: Keys in 'ALL_STATS': {list(results_dict['ALL_STATS'].keys())}"
+                        )
     return results_matrix
 
 
@@ -422,9 +432,13 @@ def common_timeseries_extraction(
         use_metric_context_path = cleaned_metric[5]
 
         # Debug logging for metric extraction
-        logging.info(f"Extracted metric - JSONPath: '{metric_jsonpath}', Name: '{metric_name}', Value: {metric_value}")
+        logging.info(
+            f"Extracted metric - JSONPath: '{metric_jsonpath}', Name: '{metric_name}', Value: {metric_value}"
+        )
         if "ALL_STATS.Totals.Ops/sec" in metric_name or "ALL STATS" in metric_jsonpath:
-            logging.warning(f"DEBUG ALL_STATS metric - JSONPath: '{metric_jsonpath}', Name: '{metric_name}', Value: {metric_value}, Context: '{metric_context_path}')")
+            logging.warning(
+                f"DEBUG ALL_STATS metric - JSONPath: '{metric_jsonpath}', Name: '{metric_name}', Value: {metric_value}, Context: '{metric_context_path}')"
+            )
 
         target_table_keyname, target_table_dict = from_metric_kv_to_timeserie(
             break_by_key,

{redis_benchmarks_specification-0.2.19 → redis_benchmarks_specification-0.2.20}/redis_benchmarks_specification/__self_contained_coordinator__/docker.py

@@ -86,7 +86,7 @@ def spin_docker_standalone_redis(
         ceil_db_cpu_limit, current_cpu_pos
     )
     # Calculate nano_cpus for better CPU distribution
-    redis_cpu_count = len(db_cpuset_cpus.split(','))
+    redis_cpu_count = len(db_cpuset_cpus.split(","))
     redis_nano_cpus = int(redis_cpu_count * 1e9)  # 1 CPU = 1e9 nano_cpus
 
     logging.info(
@@ -94,7 +94,9 @@ def spin_docker_standalone_redis(
             run_image, db_cpuset_cpus, command_str
         )
     )
-    logging.info(f"Redis container will use {redis_cpu_count} CPUs (nano_cpus={redis_nano_cpus}) on cores {db_cpuset_cpus}")
+    logging.info(
+        f"Redis container will use {redis_cpu_count} CPUs (nano_cpus={redis_nano_cpus}) on cores {db_cpuset_cpus}"
+    )
 
     container = docker_client.containers.run(
         image=run_image,
@@ -109,7 +111,7 @@ def spin_docker_standalone_redis(
         detach=True,
         cpuset_cpus=db_cpuset_cpus,
         nano_cpus=redis_nano_cpus,  # Force CPU distribution
-      #  pid_mode="host",
+        #  pid_mode="host",
     )
     redis_containers.append(container)
     return current_cpu_pos

{redis_benchmarks_specification-0.2.19 → redis_benchmarks_specification-0.2.20}/redis_benchmarks_specification/__self_contained_coordinator__/prepopulation.py

@@ -68,10 +68,12 @@ def data_prepopulation_step(
         preload_start_time = datetime.datetime.now()
 
         # Calculate nano_cpus for better CPU distribution
-        preload_cpu_count = len(client_cpuset_cpus.split(','))
+        preload_cpu_count = len(client_cpuset_cpus.split(","))
         preload_nano_cpus = int(preload_cpu_count * 1e9)  # 1 CPU = 1e9 nano_cpus
 
-        logging.info(f"Preload container will use {preload_cpu_count} CPUs (nano_cpus={preload_nano_cpus}) on cores {client_cpuset_cpus}")
+        logging.info(
+            f"Preload container will use {preload_cpu_count} CPUs (nano_cpus={preload_nano_cpus}) on cores {client_cpuset_cpus}"
+        )
 
         client_container_stdout = docker_client.containers.run(
             image=preload_image,

{redis_benchmarks_specification-0.2.19 → redis_benchmarks_specification-0.2.20}/redis_benchmarks_specification/__self_contained_coordinator__/runners.py

@@ -541,10 +541,14 @@ def process_self_contained_coordinator_stream(
                             benchmark_start_time = datetime.datetime.now()
 
                             # Calculate nano_cpus for better CPU distribution
-                            client_cpu_count = len(client_cpuset_cpus.split(','))
-                            client_nano_cpus = int(client_cpu_count * 1e9)  # 1 CPU = 1e9 nano_cpus
+                            client_cpu_count = len(client_cpuset_cpus.split(","))
+                            client_nano_cpus = int(
+                                client_cpu_count * 1e9
+                            )  # 1 CPU = 1e9 nano_cpus
 
-                            logging.info(f"Client container will use {client_cpu_count} CPUs (nano_cpus={client_nano_cpus}) on cores {client_cpuset_cpus}")
+                            logging.info(
+                                f"Client container will use {client_cpu_count} CPUs (nano_cpus={client_nano_cpus}) on cores {client_cpuset_cpus}"
+                            )
 
                             client_container_stdout = docker_client.containers.run(
                                 image=client_container_image,

{redis_benchmarks_specification-0.2.19 → redis_benchmarks_specification-0.2.20}/redis_benchmarks_specification/__self_contained_coordinator__/self_contained_coordinator.py

@@ -1408,7 +1408,9 @@ def process_self_contained_coordinator_stream(
                                     run_image,
                                     temporary_dir,
                                     auto_remove=False,
-                                    enable_cpu_distribution=args.enable_cpu_distribution if args else False,
+                                    enable_cpu_distribution=(
+                                        args.enable_cpu_distribution if args else False
+                                    ),
                                 )
 
                                 r = redis.StrictRedis(
@@ -1622,21 +1624,37 @@ def process_self_contained_coordinator_stream(
                                 }
 
                                 # Add CPU distribution settings if enabled
-                                enable_cpu_distribution = args.enable_cpu_distribution if args else False
+                                enable_cpu_distribution = (
+                                    args.enable_cpu_distribution if args else False
+                                )
                                 if enable_cpu_distribution:
-                                    client_cpu_count = len(client_cpuset_cpus.split(','))
-                                    client_nano_cpus = int(client_cpu_count * 1e9)  # 1 CPU = 1e9 nano_cpus
+                                    client_cpu_count = len(
+                                        client_cpuset_cpus.split(",")
+                                    )
+                                    client_nano_cpus = int(
+                                        client_cpu_count * 1e9
+                                    )  # 1 CPU = 1e9 nano_cpus
 
-                                    client_container_args["cpuset_cpus"] = client_cpuset_cpus
-                                    client_container_args["nano_cpus"] = client_nano_cpus
+                                    client_container_args["cpuset_cpus"] = (
+                                        client_cpuset_cpus
+                                    )
+                                    client_container_args["nano_cpus"] = (
+                                        client_nano_cpus
+                                    )
 
-                                    logging.info(f"Client container will use {client_cpu_count} CPUs (nano_cpus={client_nano_cpus}) on cores {client_cpuset_cpus} [CPU distribution enabled]")
+                                    logging.info(
+                                        f"Client container will use {client_cpu_count} CPUs (nano_cpus={client_nano_cpus}) on cores {client_cpuset_cpus} [CPU distribution enabled]"
+                                    )
                                 else:
-                                    logging.info(f"Client container will use default CPU allocation [CPU distribution disabled]")
+                                    logging.info(
+                                        f"Client container will use default CPU allocation [CPU distribution disabled]"
+                                    )
 
                                 try:
                                     # Start container with detach=True to enable timeout handling
-                                    container = docker_client.containers.run(**client_container_args)
+                                    container = docker_client.containers.run(
+                                        **client_container_args
+                                    )
 
                                     logging.info(
                                         f"Started container {container.name} ({container.id[:12]}) with {container_timeout}s timeout"
@@ -1645,31 +1663,62 @@ def process_self_contained_coordinator_stream(
                                     # Apply CPU affinity using taskset if CPU distribution is enabled
                                     if enable_cpu_distribution:
                                         try:
-                                            container_info = docker_client.api.inspect_container(container.id)
-                                            container_pid = container_info['State']['Pid']
+                                            container_info = (
+                                                docker_client.api.inspect_container(
+                                                    container.id
+                                                )
+                                            )
+                                            container_pid = container_info["State"][
+                                                "Pid"
+                                            ]
 
-                                            logging.info(f"Setting CPU affinity for client container PID {container_pid} to cores {client_cpuset_cpus}")
+                                            logging.info(
+                                                f"Setting CPU affinity for client container PID {container_pid} to cores {client_cpuset_cpus}"
+                                            )
 
                                             # Set CPU affinity for the main process and all its threads
-                                            subprocess.run(f"taskset -cp {client_cpuset_cpus} {container_pid}", shell=True, check=True)
+                                            subprocess.run(
+                                                f"taskset -cp {client_cpuset_cpus} {container_pid}",
+                                                shell=True,
+                                                check=True,
+                                            )
 
                                             # Wait a moment for client to start its threads, then set affinity for all child processes
                                             time.sleep(1)
-                                            result = subprocess.run(f"pgrep -P {container_pid}", shell=True, capture_output=True, text=True)
+                                            result = subprocess.run(
+                                                f"pgrep -P {container_pid}",
+                                                shell=True,
+                                                capture_output=True,
+                                                text=True,
+                                            )
                                             if result.returncode == 0:
-                                                child_pids = result.stdout.strip().split('\n')
+                                                child_pids = (
+                                                    result.stdout.strip().split("\n")
+                                                )
                                                 for child_pid in child_pids:
                                                     if child_pid.strip():
                                                         try:
-                                                            subprocess.run(f"taskset -cp {client_cpuset_cpus} {child_pid.strip()}", shell=True, check=True)
-                                                            logging.info(f"Set CPU affinity for client child process {child_pid.strip()}")
-                                                        except subprocess.CalledProcessError:
+                                                            subprocess.run(
+                                                                f"taskset -cp {client_cpuset_cpus} {child_pid.strip()}",
+                                                                shell=True,
+                                                                check=True,
+                                                            )
+                                                            logging.info(
+                                                                f"Set CPU affinity for client child process {child_pid.strip()}"
+                                                            )
+                                                        except (
+                                                            subprocess.CalledProcessError
+                                                        ):
                                                             pass  # Child process may have exited
 
-                                            logging.info(f"✅ Applied CPU affinity to client container and all child processes")
+                                            logging.info(
+                                                f"✅ Applied CPU affinity to client container and all child processes"
+                                            )
 
                                         except Exception as e:
-                                            logging.warning(f"Failed to set CPU affinity for client container: {e}")
+                                            logging.warning(
+                                                f"Failed to set CPU affinity for client container: {e}"
+                                            )
 
                                     # Wait for container with timeout
                                     try:
@@ -2313,15 +2362,19 @@ def start_redis_container(
 
     # Add CPU distribution settings if enabled
     if enable_cpu_distribution:
-        redis_cpu_count = len(db_cpuset_cpus.split(','))
+        redis_cpu_count = len(db_cpuset_cpus.split(","))
         redis_nano_cpus = int(redis_cpu_count * 1e9)  # 1 CPU = 1e9 nano_cpus
 
         container_args["cpuset_cpus"] = db_cpuset_cpus
         container_args["nano_cpus"] = redis_nano_cpus
 
-        logging.info(f"Redis container will use {redis_cpu_count} CPUs (nano_cpus={redis_nano_cpus}) on cores {db_cpuset_cpus} [CPU distribution enabled]")
+        logging.info(
+            f"Redis container will use {redis_cpu_count} CPUs (nano_cpus={redis_nano_cpus}) on cores {db_cpuset_cpus} [CPU distribution enabled]"
+        )
     else:
-        logging.info(f"Redis container will use default CPU allocation [CPU distribution disabled]")
+        logging.info(
+            f"Redis container will use default CPU allocation [CPU distribution disabled]"
+        )
 
     redis_container = docker_client.containers.run(**container_args)
     time.sleep(5)
@@ -2330,27 +2383,41 @@ def start_redis_container(
     if enable_cpu_distribution:
         try:
             container_info = docker_client.api.inspect_container(redis_container.id)
-            container_pid = container_info['State']['Pid']
+            container_pid = container_info["State"]["Pid"]
 
-            logging.info(f"Setting CPU affinity for Redis container PID {container_pid} to cores {db_cpuset_cpus}")
+            logging.info(
+                f"Setting CPU affinity for Redis container PID {container_pid} to cores {db_cpuset_cpus}"
+            )
 
             # Set CPU affinity for the main Redis process and all its threads
-            subprocess.run(f"taskset -cp {db_cpuset_cpus} {container_pid}", shell=True, check=True)
+            subprocess.run(
+                f"taskset -cp {db_cpuset_cpus} {container_pid}", shell=True, check=True
+            )
 
             # Wait a moment for Redis to start its IO threads, then set affinity for all Redis processes
             time.sleep(2)
-            result = subprocess.run(f"pgrep -P {container_pid}", shell=True, capture_output=True, text=True)
+            result = subprocess.run(
+                f"pgrep -P {container_pid}", shell=True, capture_output=True, text=True
+            )
             if result.returncode == 0:
-                child_pids = result.stdout.strip().split('\n')
+                child_pids = result.stdout.strip().split("\n")
                 for child_pid in child_pids:
                     if child_pid.strip():
                         try:
-                            subprocess.run(f"taskset -cp {db_cpuset_cpus} {child_pid.strip()}", shell=True, check=True)
-                            logging.info(f"Set CPU affinity for Redis child process {child_pid.strip()}")
+                            subprocess.run(
+                                f"taskset -cp {db_cpuset_cpus} {child_pid.strip()}",
+                                shell=True,
+                                check=True,
+                            )
+                            logging.info(
+                                f"Set CPU affinity for Redis child process {child_pid.strip()}"
+                            )
                         except subprocess.CalledProcessError:
                             pass  # Child process may have exited
 
-            logging.info(f"✅ Applied CPU affinity to Redis container and all child processes")
+            logging.info(
+                f"✅ Applied CPU affinity to Redis container and all child processes"
+            )
 
         except Exception as e:
             logging.warning(f"Failed to set CPU affinity for Redis container: {e}")
@@ -2563,15 +2630,19 @@ def data_prepopulation_step(
         # Add CPU distribution settings if enabled
         enable_cpu_distribution = args.enable_cpu_distribution if args else False
         if enable_cpu_distribution:
-            preload_cpu_count = len(client_cpuset_cpus.split(','))
+            preload_cpu_count = len(client_cpuset_cpus.split(","))
             preload_nano_cpus = int(preload_cpu_count * 1e9)  # 1 CPU = 1e9 nano_cpus
 
             preload_container_args["cpuset_cpus"] = client_cpuset_cpus
             preload_container_args["nano_cpus"] = preload_nano_cpus
 
-            logging.info(f"Preload container will use {preload_cpu_count} CPUs (nano_cpus={preload_nano_cpus}) on cores {client_cpuset_cpus} [CPU distribution enabled]")
+            logging.info(
+                f"Preload container will use {preload_cpu_count} CPUs (nano_cpus={preload_nano_cpus}) on cores {client_cpuset_cpus} [CPU distribution enabled]"
+            )
         else:
-            logging.info(f"Preload container will use default CPU allocation [CPU distribution disabled]")
+            logging.info(
+                f"Preload container will use default CPU allocation [CPU distribution disabled]"
+            )
 
         try:
             # Start container with detach=True to enable timeout handling