redis-benchmarks-specification 0.2.24__py3-none-any.whl → 0.2.25__py3-none-any.whl

redis_benchmarks_specification/__builder__/builder.py

@@ -538,7 +538,7 @@ def builder_process_stream(
                     server_name = testDetails[b"server_name"].decode()
 
                 # Check if artifacts already exist before building
-                prefix = f"github_org={github_org}/github_repo={github_repo}/git_branch={str(git_branch)}/git_version={str(git_version)}/git_hash={str(git_hash)}"
+                prefix = f"build_spec={build_spec}/github_org={github_org}/github_repo={github_repo}/git_branch={str(git_branch)}/git_version={str(git_version)}/git_hash={str(git_hash)}"
 
                 # Create a comprehensive build signature that includes all build-affecting parameters
                 import hashlib

redis_benchmarks_specification/__cli__/cli.py

@@ -126,9 +126,7 @@ def trigger_tests_dockerhub_cli_command_logic(args, project_name, project_versio
 
     if result is True:
         # Use architecture-specific stream
-        # Provide default arch if None (defensive programming for tests)
-        arch = args.arch if args.arch is not None else "amd64"
-        arch_specific_stream = get_arch_specific_stream_name(arch)
+        arch_specific_stream = get_arch_specific_stream_name(args.arch)
         logging.info(
             f"CLI adding work to architecture-specific stream: {arch_specific_stream}"
         )
@@ -220,7 +218,7 @@ def get_commits_by_tags(args, repo):
                 version.Version(tag.name)
                 match_obj = re.search(tags_regex_string, tag.name)
                 if match_obj is None:
-                    logging.debug(
+                    logging.info(
                         "Skipping {} given it does not match regex {}".format(
                             tag.name, tags_regexp
                         )
@@ -389,7 +387,7 @@ def trigger_tests_cli_command_logic(args, project_name, project_version):
         commit_datetime = cdict["commit_datetime"]
         match_obj = re.search(hash_regexp_string, commit_hash)
         if match_obj is None:
-            logging.debug(
+            logging.info(
                 "Skipping {} given it does not match regex {}".format(
                     commit_hash, hash_regexp_string
                 )

redis_benchmarks_specification/__common__/timeseries.py

@@ -136,17 +136,6 @@ def extract_results_table(
                 # Always use context path for precision_summary metrics to show actual precision levels
                 if "precision_summary" in metric_jsonpath and "*" in metric_jsonpath:
                     use_metric_context_path = True
-
-                # 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}'"
-                    )
-                    for i, result in enumerate(find_res):
-                        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)
                     metric_value = float(metric.value)
@@ -211,19 +200,6 @@ def extract_results_table(
                 logging.warning(
                     "Unable to find metric path {} in result dict".format(jsonpath)
                 )
-                # 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())}"
-                    )
-                    if "ALL STATS" in results_dict:
-                        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())}"
-                        )
     return results_matrix
 
 
@@ -431,15 +407,6 @@ def common_timeseries_extraction(
         test_case_targets_dict = cleaned_metric[4]
         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}"
-        )
-        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}')"
-            )
-
         target_table_keyname, target_table_dict = from_metric_kv_to_timeserie(
             break_by_key,
             break_by_str,

redis_benchmarks_specification/__self_contained_coordinator__/args.py

@@ -207,10 +207,4 @@ def create_self_contained_coordinator_args(project_name):
         action="store_true",
         help="Skip automatically clearing pending messages and resetting consumer group position on startup. By default, pending messages are cleared and consumer group is reset to latest position to skip old work and recover from crashes.",
     )
-    parser.add_argument(
-        "--enable-cpu-distribution",
-        default=False,
-        action="store_true",
-        help="Enable CPU distribution optimization using Docker cpuset_cpus and nano_cpus parameters. This forces better CPU core distribution for Redis and client containers. Disabled by default.",
-    )
     return parser

redis_benchmarks_specification/__self_contained_coordinator__/docker.py

@@ -85,19 +85,11 @@ def spin_docker_standalone_redis(
     db_cpuset_cpus, current_cpu_pos = generate_cpuset_cpus(
         ceil_db_cpu_limit, current_cpu_pos
     )
-    # Calculate nano_cpus for better CPU distribution
-    redis_cpu_count = len(db_cpuset_cpus.split(","))
-    redis_nano_cpus = int(redis_cpu_count * 1e9)  # 1 CPU = 1e9 nano_cpus
-
     logging.info(
         "Running redis-server on docker image {} (cpuset={}) with the following args: {}".format(
             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}"
-    )
-
     container = docker_client.containers.run(
         image=run_image,
         volumes={
@@ -110,8 +102,7 @@ def spin_docker_standalone_redis(
         network_mode="host",
         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

@@ -67,14 +67,6 @@ def data_prepopulation_step(
         # run the benchmark
         preload_start_time = datetime.datetime.now()
 
-        # Calculate nano_cpus for better CPU distribution
-        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}"
-        )
-
         client_container_stdout = docker_client.containers.run(
             image=preload_image,
             volumes={
@@ -90,7 +82,6 @@ def data_prepopulation_step(
             network_mode="host",
             detach=False,
             cpuset_cpus=client_cpuset_cpus,
-            nano_cpus=preload_nano_cpus,  # Force CPU distribution
         )
 
         preload_end_time = datetime.datetime.now()

redis_benchmarks_specification/__self_contained_coordinator__/runners.py

@@ -540,16 +540,6 @@ def process_self_contained_coordinator_stream(
                             # run the benchmark
                             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
-
-                            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,
                                 volumes={
@@ -565,7 +555,6 @@ def process_self_contained_coordinator_stream(
                                 network_mode="host",
                                 detach=False,
                                 cpuset_cpus=client_cpuset_cpus,
-                                nano_cpus=client_nano_cpus,  # Force CPU distribution
                             )
 
                             benchmark_end_time = datetime.datetime.now()

redis_benchmarks_specification/__self_contained_coordinator__/self_contained_coordinator.py

@@ -772,7 +772,6 @@ def main():
             priority_upper_limit,
             default_baseline_branch,
             default_metrics_str,
-            args=args,
         )
 
 
@@ -809,7 +808,6 @@ def self_contained_coordinator_blocking_read(
     default_metrics_str="ALL_STATS.Totals.Ops/sec",
     docker_keep_env=False,
     restore_build_artifacts_default=True,
-    args=None,
 ):
     num_process_streams = 0
     num_process_test_suites = 0
@@ -1407,10 +1405,6 @@ def process_self_contained_coordinator_stream(
                                     redis_containers,
                                     run_image,
                                     temporary_dir,
-                                    auto_remove=False,
-                                    enable_cpu_distribution=(
-                                        getattr(args, 'enable_cpu_distribution', False) if args else False
-                                    ),
                                 )
 
                                 r = redis.StrictRedis(
@@ -1470,7 +1464,6 @@ def process_self_contained_coordinator_stream(
                                         temporary_dir,
                                         test_name,
                                         redis_password,
-                                        args,
                                     )
 
                                 execute_init_commands(
@@ -1607,120 +1600,29 @@ def process_self_contained_coordinator_stream(
                                         f"Using default container timeout: {container_timeout}s"
                                     )
 
-                                # Prepare client container arguments
-                                client_container_args = {
-                                    "image": client_container_image,
-                                    "volumes": {
-                                        temporary_dir_client: {
-                                            "bind": client_mnt_point,
-                                            "mode": "rw",
-                                        },
-                                    },
-                                    "auto_remove": False,  # Don't auto-remove so we can get logs if timeout
-                                    "privileged": True,
-                                    "working_dir": benchmark_tool_workdir,
-                                    "command": benchmark_command_str,
-                                    "network_mode": "host",
-                                    "detach": True,  # Detach to enable timeout
-                                }
-
-                                # Add CPU distribution settings if enabled
-                                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_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]"
-                                    )
-                                else:
-                                    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
+                                        image=client_container_image,
+                                        volumes={
+                                            temporary_dir_client: {
+                                                "bind": client_mnt_point,
+                                                "mode": "rw",
+                                            },
+                                        },
+                                        auto_remove=False,  # Don't auto-remove so we can get logs if timeout
+                                        privileged=True,
+                                        working_dir=benchmark_tool_workdir,
+                                        command=benchmark_command_str,
+                                        network_mode="host",
+                                        detach=True,  # Detach to enable timeout
+                                        cpuset_cpus=client_cpuset_cpus,
                                     )
 
                                     logging.info(
                                         f"Started container {container.name} ({container.id[:12]}) with {container_timeout}s timeout"
                                     )
 
-                                    # 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"
-                                            ]
-
-                                            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,
-                                            )
-
-                                            # 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,
-                                            )
-                                            if result.returncode == 0:
-                                                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
-                                                        ):
-                                                            pass  # Child process may have exited
-
-                                            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}"
-                                            )
-
                                     # Wait for container with timeout
                                     try:
                                         result = container.wait(
@@ -2329,7 +2231,6 @@ def start_redis_container(
     run_image,
     temporary_dir,
     auto_remove=False,
-    enable_cpu_distribution=False,
 ):
     logging.info(
         "Running redis-server on docker image {} (cpuset={}) with the following args: {}".format(
@@ -2347,82 +2248,20 @@ def start_redis_container(
         }
         logging.info(f"setting volume as follow: {volumes}. working_dir={mnt_point}")
         working_dir = mnt_point
-
-    # Prepare container arguments
-    container_args = {
-        "image": run_image,
-        "volumes": volumes,
-        "auto_remove": auto_remove,
-        "privileged": True,
-        "working_dir": mnt_point,
-        "command": command_str,
-        "network_mode": "host",
-        "detach": True,
-        "publish_all_ports": True,
-    }
-
-    # Add CPU distribution settings if enabled
-    if enable_cpu_distribution:
-        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]"
-        )
-    else:
-        logging.info(
-            f"Redis container will use default CPU allocation [CPU distribution disabled]"
-        )
-
-    redis_container = docker_client.containers.run(**container_args)
+    redis_container = docker_client.containers.run(
+        image=run_image,
+        volumes=volumes,
+        auto_remove=auto_remove,
+        privileged=True,
+        working_dir=mnt_point,
+        command=command_str,
+        network_mode="host",
+        detach=True,
+        cpuset_cpus=db_cpuset_cpus,
+        pid_mode="host",
+        publish_all_ports=True,
+    )
     time.sleep(5)
-
-    # Apply CPU affinity using taskset if CPU distribution is enabled
-    if enable_cpu_distribution:
-        try:
-            container_info = docker_client.api.inspect_container(redis_container.id)
-            container_pid = container_info["State"]["Pid"]
-
-            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
-            )
-
-            # 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
-            )
-            if result.returncode == 0:
-                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()}"
-                            )
-                        except subprocess.CalledProcessError:
-                            pass  # Child process may have exited
-
-            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}")
-
     redis_containers.append(redis_container)
     return redis_container
 
@@ -2442,14 +2281,14 @@ def filter_test_files(
             continue
 
         if tests_regexp != ".*":
-            logging.debug(
+            logging.info(
                 "Filtering all tests via a regular expression: {}".format(tests_regexp)
             )
             tags_regex_string = re.compile(tests_regexp)
 
             match_obj = re.search(tags_regex_string, test_file)
             if match_obj is None:
-                logging.debug(
+                logging.info(
                     "Skipping {} given it does not match regex {}".format(
                         test_file, tests_regexp
                     )
@@ -2563,7 +2402,6 @@ def data_prepopulation_step(
     temporary_dir,
     test_name,
     redis_password,
-    args=None,
 ):
     # setup the benchmark
     (
@@ -2612,43 +2450,24 @@ def data_prepopulation_step(
         preload_timeout = 1800  # 30 minutes default for data loading
         logging.info(f"Starting preload container with {preload_timeout}s timeout")
 
-        # Prepare preload container arguments
-        preload_container_args = {
-            "image": preload_image,
-            "volumes": {
-                temporary_dir: {
-                    "bind": client_mnt_point,
-                    "mode": "rw",
-                },
-            },
-            "auto_remove": False,  # Don't auto-remove so we can get logs if timeout
-            "privileged": True,
-            "working_dir": benchmark_tool_workdir,
-            "command": preload_command_str,
-            "network_mode": "host",
-            "detach": True,  # Detach to enable timeout
-        }
-
-        # Add CPU distribution settings if enabled
-        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_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]"
-            )
-        else:
-            logging.info(
-                f"Preload container will use default CPU allocation [CPU distribution disabled]"
-            )
-
         try:
             # Start container with detach=True to enable timeout handling
-            container = docker_client.containers.run(**preload_container_args)
+            container = docker_client.containers.run(
+                image=preload_image,
+                volumes={
+                    temporary_dir: {
+                        "bind": client_mnt_point,
+                        "mode": "rw",
+                    },
+                },
+                auto_remove=False,  # Don't auto-remove so we can get logs if timeout
+                privileged=True,
+                working_dir=benchmark_tool_workdir,
+                command=preload_command_str,
+                network_mode="host",
+                detach=True,  # Detach to enable timeout
+                cpuset_cpus=client_cpuset_cpus,
+            )
 
             logging.info(
                 f"Started preload container {container.name} ({container.id[:12]}) with {preload_timeout}s timeout"

redis_benchmarks_specification/__spec__/cli.py

@@ -137,7 +137,7 @@ def cli_command_logic(args, project_name, project_version):
                     version.Version(tag.name)
                     match_obj = re.search(tags_regex_string, tag.name)
                     if match_obj is None:
-                        logging.debug(
+                        logging.info(
                             "Skipping {} given it does not match regex {}".format(
                                 tag.name, tags_regexp
                             )
@@ -190,7 +190,7 @@ def cli_command_logic(args, project_name, project_version):
         commit_summary = cdict["commit_summary"]
         match_obj = re.search(hash_regexp_string, commit_hash)
         if match_obj is None:
-            logging.debug(
+            logging.info(
                 "Skipping {} given it does not match regex {}".format(
                     commit_hash, hash_regexp_string
                 )

redis_benchmarks_specification/setups/topologies/topologies.yml

@@ -26,10 +26,10 @@ spec:
     redis_topology:
       primaries: 1
       replicas: 0
-    redis_arguments: --io-threads 2 --io-threads-do-reads yes 
+    redis_arguments: --io-threads 2 --io-threads-do-reads yes
     resources:
       requests:
-        cpus: "2"
+        cpus: "3"
         memory: "10g"
 
   - name: oss-standalone-04-io-threads
@@ -37,10 +37,10 @@ spec:
     redis_topology:
       primaries: 1
       replicas: 0
-    redis_arguments: --io-threads 4 --io-threads-do-reads yes 
+    redis_arguments: --io-threads 4 --io-threads-do-reads yes
     resources:
       requests:
-        cpus: "4"
+        cpus: "5"
         memory: "10g"
 
   - name: oss-standalone-08-io-threads
@@ -48,10 +48,10 @@ spec:
     redis_topology:
       primaries: 1
       replicas: 0
-    redis_arguments: --io-threads 8 --io-threads-do-reads yes 
+    redis_arguments: --io-threads 8 --io-threads-do-reads yes
     resources:
       requests:
-        cpus: "8"
+        cpus: "9"
         memory: "10g"
 
   - name: oss-standalone-16-io-threads
@@ -62,7 +62,7 @@ spec:
     redis_arguments: --io-threads 16 --io-threads-do-reads yes
     resources:
       requests:
-        cpus: "16"
+        cpus: "17"
         memory: "10g"
 
   - name: oss-standalone-32-io-threads
@@ -73,7 +73,7 @@ spec:
     redis_arguments: --io-threads 32 --io-threads-do-reads yes
     resources:
       requests:
-        cpus: "32"
+        cpus: "33"
         memory: "10g"
 
   - name: oss-standalone-64-io-threads
@@ -84,7 +84,7 @@ spec:
     redis_arguments: --io-threads 64 --io-threads-do-reads yes
     resources:
       requests:
-        cpus: "64"
+        cpus: "65"
         memory: "10g"
   - name: oss-standalone-1replica
     type: oss-standalone

redis_benchmarks_specification/test-suites/memtier_benchmark-1Mkeys-string-setget200c-1KiB-pipeline-10.yml

@@ -24,9 +24,6 @@ tested-commands:
 tested-groups:
 - string
 redis-topologies:
-- oss-standalone-08-io-threads
-- oss-standalone-04-io-threads
-- oss-standalone-02-io-threads
 - oss-standalone
 build-variants:
 - gcc:15.2.0-amd64-debian-bookworm-default

redis_benchmarks_specification/test-suites/memtier_benchmark-multiple-hll-pfcount-100B-values.yml

@@ -0,0 +1,34 @@
+version: 0.4
+name: memtier_benchmark-multiple-hll-pfcount-100B-values
+description: Runs memtier_benchmark, pre-loading multiple HyperLogLog keys with 100B sized random elements using PFADD, then testing PFCOUNT performance by counting these pre-loaded HLLs.
+dbconfig:
+  configuration-parameters:
+    save: '""'
+  check:
+    keyspacelen: 3
+  preload_tool:
+    run_image: redislabs/memtier_benchmark:edge
+    tool: memtier_benchmark
+    arguments: '"--data-size" "100" --random-data --command "PFADD __key__ __data__" --command-key-pattern="P" --key-minimum=1 --key-maximum 3 -n 30000 -c 1 -t 1 --hide-histogram'
+  resources:
+    requests:
+      memory: 2g
+tested-groups:
+- hyperloglog
+tested-commands:
+- pfcount
+redis-topologies:
+- oss-standalone
+build-variants:
+- gcc:15.2.0-amd64-debian-bookworm-default
+- gcc:15.2.0-arm64-debian-bookworm-default
+- dockerhub
+clientconfig:
+  run_image: redislabs/memtier_benchmark:edge
+  tool: memtier_benchmark
+  arguments: --test-time 60 --command "PFCOUNT memtier-1 memtier-2 memtier-3" -c 50 -t 4 --hide-histogram
+  resources:
+    requests:
+      cpus: '4'
+      memory: 2g
+priority: 62