redis-benchmarks-specification 0.2.19__py3-none-any.whl → 0.2.21__py3-none-any.whl

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/__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/__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/__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/__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=(
+                                        getattr(args, 'enable_cpu_distribution', False) 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 = (
+                                    getattr(args, 'enable_cpu_distribution', False) 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}")
@@ -2561,17 +2628,21 @@ def data_prepopulation_step(
         }
 
         # Add CPU distribution settings if enabled
-        enable_cpu_distribution = args.enable_cpu_distribution if args else False
+        enable_cpu_distribution = getattr(args, 'enable_cpu_distribution', False) 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

{redis_benchmarks_specification-0.2.19.dist-info → redis_benchmarks_specification-0.2.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis-benchmarks-specification
-Version: 0.2.19
+Version: 0.2.21
 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.dist-info → redis_benchmarks_specification-0.2.21.dist-info}/RECORD

@@ -18,7 +18,7 @@ redis_benchmarks_specification/__common__/package.py,sha256=4uVt1BAZ999LV2rZkq--
 redis_benchmarks_specification/__common__/runner.py,sha256=TKMUFJ3nLSfmSU7P_ok9oM5-pI4L4tFxsWLUWaUHhbI,16733
 redis_benchmarks_specification/__common__/spec.py,sha256=D_SN48wg6NMthW_-OS1H5bydSDiuZpfd4WPPj7Vfwmc,5760
 redis_benchmarks_specification/__common__/suppress_warnings.py,sha256=xpOjJ_piGYWlGq9ITr-ZwSCl2GpreA9juZIBao4fDRs,691
-redis_benchmarks_specification/__common__/timeseries.py,sha256=EzNTts2aUS_GoEGaMcl1wpKkFWQ1txseHUfuNGSaSqU,55739
+redis_benchmarks_specification/__common__/timeseries.py,sha256=HxCLQmS1JCaxympxMxMk92HHnmfKehIigZ6GZZWHoLw,56045
 redis_benchmarks_specification/__compare__/__init__.py,sha256=DtBXRp0Q01XgCFmY-1OIePMyyYihVNAjZ1Y8zwqSDN0,101
 redis_benchmarks_specification/__compare__/args.py,sha256=CNtA7pI9CJDTBJPGL2pNVfis7VDdxLautwRyka7oUCI,8911
 redis_benchmarks_specification/__compare__/compare.py,sha256=_AbuV3FZxtUZIdq4qq24LNzPNIdtQQaqrk8bUjn9blk,84327
@@ -33,11 +33,11 @@ redis_benchmarks_specification/__self_contained_coordinator__/artifacts.py,sha25
 redis_benchmarks_specification/__self_contained_coordinator__/build_info.py,sha256=vlg8H8Rxu2falW8xp1GvL1SV1fyBguSbz6Apxc7A2yM,2282
 redis_benchmarks_specification/__self_contained_coordinator__/clients.py,sha256=EL1V4-i-tTav1mcF_CUosqPF3Q1qi9BZL0zFajEk70c,1878
 redis_benchmarks_specification/__self_contained_coordinator__/cpuset.py,sha256=sRvtoJIitppcOpm3R5LbVmSfPEAqPumOqVATnF5Wbek,594
-redis_benchmarks_specification/__self_contained_coordinator__/docker.py,sha256=eeRv7GzDVfRDijc6ucjMIO-SNGThE7rTKEBTm_dtN9s,3526
+redis_benchmarks_specification/__self_contained_coordinator__/docker.py,sha256=TuJrnijaK_5Sw9GVL6vi9H1m7f9p3g9c1f7kpU_RHuM,3542
 redis_benchmarks_specification/__self_contained_coordinator__/post_processing.py,sha256=sVLKNnWdAqYY9DjVdqRC5tDaIrVSaI3Ca7w8-DQ-LRM,776
-redis_benchmarks_specification/__self_contained_coordinator__/prepopulation.py,sha256=VYGwUiIV382AjXTeYTOImPENzw2zf2VPQM2HvaZgE_M,3368
-redis_benchmarks_specification/__self_contained_coordinator__/runners.py,sha256=kpSNvliGOEBUa8aXXk9M1rb5jKmBI6QqC0znf2lz0kw,34110
-redis_benchmarks_specification/__self_contained_coordinator__/self_contained_coordinator.py,sha256=vi2hOOGpHBbIbePMVYCsEan08NbvpSknKw0rM3421l8,120185
+redis_benchmarks_specification/__self_contained_coordinator__/prepopulation.py,sha256=30SU8dAKmRpznjAKbs1n0iHO-CjG5goCuR5TYx7XIMc,3390
+redis_benchmarks_specification/__self_contained_coordinator__/runners.py,sha256=yHgRpNeuBcft6sEeiT12qQ012xXypXsVM8Ov91CE2k0,34234
+redis_benchmarks_specification/__self_contained_coordinator__/self_contained_coordinator.py,sha256=4BoyeizeDnESrYmWt12loP5Z-KbSRm9F56hT7ILlg2A,122966
 redis_benchmarks_specification/__setups__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 redis_benchmarks_specification/__setups__/topologies.py,sha256=xQ1IJkcTji_ZjLiJd3vOxZpvbNtBLZw9cPkw5hGJKHU,481
 redis_benchmarks_specification/__spec__/__init__.py,sha256=l-G1z-t6twUgi8QLueqoTQLvJmv3hJoEYskGm6H7L6M,83
@@ -287,8 +287,8 @@ redis_benchmarks_specification/test-suites/memtier_benchmark-playbook-session-st
 redis_benchmarks_specification/test-suites/memtier_benchmark-playbook-session-storage-1k-sessions.yml,sha256=2egtIxPxCze2jlbAfgsk4v9JSQHNMoPLbDWFEW8olDg,7006
 redis_benchmarks_specification/test-suites/template.txt,sha256=ezqGiRPOvuSDO0iG7GEf-AGXNfHbgXI89_G0RUEzL88,481
 redis_benchmarks_specification/vector-search-test-suites/vector_db_benchmark_test.yml,sha256=PD7ow-k4Ll2BkhEC3aIqiaCZt8Hc4aJIp96Lw3J3mcI,791
-redis_benchmarks_specification-0.2.19.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-redis_benchmarks_specification-0.2.19.dist-info/METADATA,sha256=FlUSC9vHASXRp0K8PmOJfZK0zr_hXwmtFG7kYBCk630,22767
-redis_benchmarks_specification-0.2.19.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-redis_benchmarks_specification-0.2.19.dist-info/entry_points.txt,sha256=x5WBXCZsnDRTZxV7SBGmC65L2k-ygdDOxV8vuKN00Nk,715
-redis_benchmarks_specification-0.2.19.dist-info/RECORD,,
+redis_benchmarks_specification-0.2.21.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+redis_benchmarks_specification-0.2.21.dist-info/METADATA,sha256=J3gaSNDYZZF8N-WqtCg3SsVnfavQHaBvepJAVvMypyY,22767
+redis_benchmarks_specification-0.2.21.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+redis_benchmarks_specification-0.2.21.dist-info/entry_points.txt,sha256=x5WBXCZsnDRTZxV7SBGmC65L2k-ygdDOxV8vuKN00Nk,715
+redis_benchmarks_specification-0.2.21.dist-info/RECORD,,