redis-benchmarks-specification 0.1.291__py3-none-any.whl → 0.1.293__py3-none-any.whl

redis_benchmarks_specification/__runner__/runner.py

@@ -4,6 +4,7 @@ import logging
 import math
 import os
 import shutil
+import signal
 import subprocess
 import sys
 import tempfile
@@ -66,6 +67,23 @@ from redis_benchmarks_specification.__runner__.args import create_client_runner_
 from redis_benchmarks_specification.__runner__.remote_profiling import RemoteProfiler
 
 
+# Global flag to track if user wants to exit
+_exit_requested = False
+
+
+def signal_handler(signum, frame):
+    """Handle Ctrl+C signal to exit gracefully"""
+    global _exit_requested
+    if not _exit_requested:
+        _exit_requested = True
+        logging.info("Ctrl+C detected. Exiting after current test completes...")
+        print("\nCtrl+C detected. Exiting after current test completes...")
+    else:
+        logging.info("Ctrl+C detected again. Force exiting...")
+        print("\nForce exiting...")
+        sys.exit(1)
+
+
 def run_local_command_with_timeout(command_str, timeout_seconds, description="command"):
     """
     Run a local command with timeout support.
@@ -203,6 +221,176 @@ def extract_expected_benchmark_duration(
     return 30
 
 
+def detect_object_encoding(redis_conn, dbconfig):
+    """
+    Detect object encoding by scanning 1% of the dataset.
+
+    Args:
+        redis_conn: Redis connection
+        dbconfig: Database configuration containing keyspace info
+
+    Returns:
+        Dict with encoding information
+    """
+    try:
+        # Get total key count
+        total_keys = redis_conn.dbsize()
+        logging.debug(f"Object encoding detection: DBSIZE reports {total_keys} keys")
+
+        if total_keys == 0:
+            logging.warning("No keys found in database for encoding detection")
+            return {
+                "encoding": "unknown",
+                "confidence": 0.0,
+                "sample_size": 0,
+                "total_keys": 0,
+                "encoding_distribution": {}
+            }
+
+        # Determine scanning strategy based on dataset size
+        if total_keys <= 1000:
+            # For small datasets, scan all keys for complete accuracy
+            sample_size = total_keys
+            scan_all_keys = True
+            logging.info(f"Scanning all {total_keys} keys (small dataset - complete analysis)")
+        else:
+            # For large datasets, sample 1% (minimum 10, maximum 1000)
+            sample_size = max(10, min(1000, int(total_keys * 0.01)))
+            scan_all_keys = False
+            logging.info(f"Sampling {sample_size} keys out of {total_keys} total keys ({(sample_size/total_keys)*100:.2f}%)")
+
+        # Use SCAN to get keys
+        encoding_counts = {}
+        scanned_keys = []
+        cursor = 0
+
+        if scan_all_keys:
+            # Scan all keys in the database
+            while True:
+                cursor, keys = redis_conn.scan(cursor=cursor, count=100)
+                scanned_keys.extend(keys)
+
+                # Break if we've completed a full scan
+                if cursor == 0:
+                    break
+        else:
+            # Sample keys until we reach our target sample size
+            while len(scanned_keys) < sample_size:
+                cursor, keys = redis_conn.scan(cursor=cursor, count=min(100, sample_size - len(scanned_keys)))
+                scanned_keys.extend(keys)
+
+                # Break if we've completed a full scan
+                if cursor == 0:
+                    break
+
+            # Limit to our target sample size
+            scanned_keys = scanned_keys[:sample_size]
+
+        logging.debug(f"SCAN completed: found {len(scanned_keys)} keys, cursor ended at {cursor}")
+
+        # If SCAN didn't find any keys but we know there are keys, try KEYS command as fallback
+        if len(scanned_keys) == 0 and total_keys > 0:
+            logging.warning(f"SCAN found no keys but DBSIZE reports {total_keys} keys. Trying KEYS fallback.")
+            try:
+                # Use KEYS * as fallback (only for small datasets to avoid blocking)
+                if total_keys <= 1000:
+                    all_keys = redis_conn.keys('*')
+                    scanned_keys = all_keys[:sample_size] if not scan_all_keys else all_keys
+                    logging.info(f"KEYS fallback found {len(scanned_keys)} keys")
+                else:
+                    logging.error(f"Cannot use KEYS fallback for large dataset ({total_keys} keys)")
+            except Exception as e:
+                logging.error(f"KEYS fallback failed: {e}")
+
+        # Final check: if we still have no keys, return early
+        if len(scanned_keys) == 0:
+            logging.error(f"No keys found for encoding detection despite DBSIZE={total_keys}")
+            return {
+                "encoding": "unknown",
+                "confidence": 0.0,
+                "sample_size": 0,
+                "total_keys": total_keys,
+                "encoding_distribution": {},
+                "is_complete_scan": scan_all_keys,
+                "error": "No keys found by SCAN or KEYS commands"
+            }
+
+        # Get encoding for each sampled key
+        successful_encodings = 0
+        for i, key in enumerate(scanned_keys):
+            try:
+                # Use the redis-py object_encoding method instead of raw command
+                encoding = redis_conn.object("ENCODING", key)
+                if isinstance(encoding, bytes):
+                    encoding = encoding.decode('utf-8')
+                elif encoding is None:
+                    # Key might have expired or been deleted
+                    logging.debug(f"Key '{key}' returned None encoding (key may have expired)")
+                    continue
+
+                encoding_counts[encoding] = encoding_counts.get(encoding, 0) + 1
+                successful_encodings += 1
+
+                # Log first few keys for debugging
+                if i < 3:
+                    logging.debug(f"Key '{key}' has encoding '{encoding}'")
+
+            except Exception as e:
+                logging.warning(f"Failed to get encoding for key {key}: {e}")
+                continue
+
+        logging.debug(f"Successfully got encoding for {successful_encodings}/{len(scanned_keys)} keys")
+
+        if not encoding_counts:
+            logging.warning(f"No object encodings detected! Scanned {len(scanned_keys)} keys, successful encodings: {successful_encodings}")
+            return {
+                "encoding": "unknown",
+                "confidence": 0.0,
+                "sample_size": 0,
+                "total_keys": total_keys,
+                "encoding_distribution": {},
+                "is_complete_scan": scan_all_keys
+            }
+
+        # Determine dominant encoding
+        total_sampled = sum(encoding_counts.values())
+        dominant_encoding = max(encoding_counts.items(), key=lambda x: x[1])
+        confidence = dominant_encoding[1] / total_sampled
+
+        # Calculate encoding distribution percentages
+        encoding_distribution = {
+            enc: (count / total_sampled) * 100
+            for enc, count in encoding_counts.items()
+        }
+
+        result = {
+            "encoding": dominant_encoding[0],
+            "confidence": confidence,
+            "sample_size": total_sampled,
+            "total_keys": total_keys,
+            "encoding_distribution": encoding_distribution,
+            "is_complete_scan": scan_all_keys
+        }
+
+        scan_type = "complete scan" if scan_all_keys else "sample"
+        logging.info(f"Object encoding analysis ({scan_type}): {dominant_encoding[0]} ({confidence*100:.1f}% confidence)")
+        if len(encoding_counts) > 1:
+            logging.info(f"Encoding distribution: {encoding_distribution}")
+
+        return result
+
+    except Exception as e:
+        logging.error(f"Failed to detect object encoding: {e}")
+        return {
+            "encoding": "error",
+            "confidence": 0.0,
+            "sample_size": 0,
+            "total_keys": 0,
+            "encoding_distribution": {},
+            "error": str(e)
+        }
+
+
 def run_multiple_clients(
     benchmark_config,
     docker_client,
@@ -631,6 +819,9 @@ def run_multiple_clients(
 
 
 def main():
+    # Register signal handler for graceful exit on Ctrl+C
+    signal.signal(signal.SIGINT, signal_handler)
+
     _, _, project_version = populate_with_poetry_data()
     project_name_suffix = "redis-benchmarks-spec-client-runner"
     project_name = f"{project_name_suffix} (solely client)"
@@ -1087,7 +1278,10 @@ def process_self_contained_coordinator_stream(
     total_test_suite_runs = 0
     dry_run_count = 0
     dry_run_tests = []  # Track test names for dry run output
+    memory_results = []  # Track memory results for memory comparison mode
+    loaded_datasets = set()  # Track datasets that have been loaded (for memory comparison mode)
     dry_run = args.dry_run
+    memory_comparison_only = args.memory_comparison_only
     dry_run_include_preload = args.dry_run_include_preload
     defaults_filename = args.defaults_filename
     override_test_runs = args.override_test_runs
@@ -1100,7 +1294,49 @@ def process_self_contained_coordinator_stream(
         _,
     ) = get_defaults(defaults_filename)
 
+    # For memory comparison mode, analyze datasets before starting
+    if memory_comparison_only:
+        unique_datasets = set()
+        total_tests_with_datasets = 0
+
+        logging.info("Analyzing datasets for memory comparison mode...")
+        for test_file in testsuite_spec_files:
+            if defaults_filename in test_file:
+                continue
+            try:
+                with open(test_file, "r") as stream:
+                    benchmark_config = yaml.safe_load(stream)
+
+                if "dbconfig" in benchmark_config:
+                    # Skip load tests (keyspacelen = 0) in memory comparison mode
+                    keyspacelen = benchmark_config["dbconfig"].get("check", {}).get("keyspacelen", None)
+                    if keyspacelen is not None and keyspacelen == 0:
+                        logging.debug(f"Skipping load test {test_file} (keyspacelen=0)")
+                        continue
+
+                    dataset_name = benchmark_config["dbconfig"].get("dataset_name")
+                    if dataset_name:
+                        unique_datasets.add(dataset_name)
+                        total_tests_with_datasets += 1
+
+            except Exception as e:
+                logging.warning(f"Error analyzing {test_file}: {e}")
+
+        logging.info(f"Memory comparison mode analysis:")
+        logging.info(f"  Total tests with datasets: {total_tests_with_datasets}")
+        logging.info(f"  Unique datasets to load: {len(unique_datasets)}")
+        logging.info(f"  Dataset ingestion savings: {total_tests_with_datasets - len(unique_datasets)} skipped loads")
+        logging.info(f"  Load tests skipped: Tests with keyspacelen=0 are automatically excluded")
+
+        if len(unique_datasets) > 0:
+            logging.info(f"  Unique datasets: {', '.join(sorted(unique_datasets))}")
+
     for test_file in tqdm.tqdm(testsuite_spec_files):
+        # Check if user requested exit via Ctrl+C
+        if _exit_requested:
+            logging.info("Exit requested by user. Stopping test execution.")
+            break
+
         if defaults_filename in test_file:
             continue
         client_containers = []
@@ -1110,6 +1346,11 @@ def process_self_contained_coordinator_stream(
                 None, None, stream, ""
             )
 
+            # Check if user requested exit via Ctrl+C
+            if _exit_requested:
+                logging.info(f"Exit requested by user. Skipping test {test_name}.")
+                break
+
             if tls_enabled:
                 test_name = test_name + "-tls"
                 logging.info(
@@ -1188,28 +1429,17 @@ def process_self_contained_coordinator_stream(
                         git_version = detected_info["github_version"]
                         logging.info(f"Auto-detected github_version: {git_version}")
 
-                    # Auto-detect git hash from server info if available
-                    if git_hash == "NA":
-                        try:
-                            server_info = r.info("server")
-                            redis_git_sha1 = server_info.get("redis_git_sha1", "")
-                            redis_build_id = server_info.get("redis_build_id", "")
-
-                            # Use git_sha1 if available and not empty/zero
-                            if redis_git_sha1 and redis_git_sha1 not in ("", "0", "00000000"):
-                                git_hash = redis_git_sha1
-                                logging.info(f"Auto-detected git_hash from redis_git_sha1: {git_hash}")
-                            # Fallback to build_id if git_sha1 is not available
-                            elif redis_build_id and redis_build_id not in ("", "0"):
-                                git_hash = redis_build_id
-                                logging.info(f"Auto-detected git_hash from redis_build_id: {git_hash}")
-                        except Exception as e:
-                            logging.warning(f"Failed to auto-detect git hash: {e}")
+                    # Auto-detect git hash if it's the default value
+                    if git_hash == "NA" and detected_info["github_hash"] != "unknown":
+                        git_hash = detected_info["github_hash"]
+                        logging.info(f"Auto-detected git_hash: {git_hash}")
 
                     # Update tf_github_org and tf_github_repo with detected values
                     tf_github_org = github_org
                     tf_github_repo = github_repo
                     redis_conns = [r]
+
+
                     if oss_cluster_api_enabled:
                         redis_conns = []
                         logging.info("updating redis connections from cluster slots")
@@ -1287,6 +1517,15 @@ def process_self_contained_coordinator_stream(
                         for conn in redis_conns:
                             conn.flushall()
 
+                        # Send MEMORY PURGE after FLUSHALL for memory comparison mode
+                        if memory_comparison_only:
+                            try:
+                                logging.info("Sending MEMORY PURGE after FLUSHALL at test start")
+                                for conn in redis_conns:
+                                    conn.execute_command("MEMORY", "PURGE")
+                            except Exception as e:
+                                logging.warning(f"MEMORY PURGE failed after FLUSHALL at test start: {e}")
+
                     benchmark_required_memory = get_benchmark_required_memory(
                         benchmark_config
                     )
@@ -1437,6 +1676,20 @@ def process_self_contained_coordinator_stream(
                             )
                             continue
 
+                        # For memory comparison mode, only run tests with dbconfig
+                        if memory_comparison_only and "dbconfig" not in benchmark_config:
+                            logging.warning(
+                                "Skipping test {} in memory comparison mode as it does not contain dbconfig".format(
+                                    test_name
+                                )
+                            )
+                            delete_temporary_files(
+                                temporary_dir_client=temporary_dir_client,
+                                full_result_path=None,
+                                benchmark_tool_global=benchmark_tool_global,
+                            )
+                            continue
+
                     if dry_run is True:
                         dry_run_count = dry_run_count + 1
                         dry_run_tests.append(test_name)
@@ -1448,46 +1701,68 @@ def process_self_contained_coordinator_stream(
                         continue
                     if "dbconfig" in benchmark_config:
                         if "preload_tool" in benchmark_config["dbconfig"]:
-                            # Get timeout buffer for preload
-                            buffer_timeout = getattr(
-                                args,
-                                "timeout_buffer",
-                                getattr(args, "container_timeout_buffer", 60),
-                            )
-
-                            res = data_prepopulation_step(
-                                benchmark_config,
-                                benchmark_tool_workdir,
-                                client_cpuset_cpus,
-                                docker_client,
-                                git_hash,
-                                port,
-                                temporary_dir_client,
-                                test_name,
-                                host,
-                                tls_enabled,
-                                tls_skip_verify,
-                                test_tls_cert,
-                                test_tls_key,
-                                test_tls_cacert,
-                                resp_version,
-                                args.benchmark_local_install,
-                                password,
-                                oss_cluster_api_enabled,
-                                unix_socket,
-                                buffer_timeout,
-                                args,
-                            )
-                            if res is False:
-                                logging.warning(
-                                    "Skipping this test given preload result was false"
+                            # Check if this dataset has already been loaded (for memory comparison mode)
+                            dataset_name = benchmark_config["dbconfig"].get("dataset_name")
+                            skip_preload = False
+
+                            if memory_comparison_only and dataset_name:
+                                if dataset_name in loaded_datasets:
+                                    logging.info(f"Skipping preload for dataset '{dataset_name}' - already loaded")
+                                    skip_preload = True
+                                else:
+                                    logging.info(f"Loading dataset '{dataset_name}' for the first time")
+                                    loaded_datasets.add(dataset_name)
+
+                            if not skip_preload:
+                                # Get timeout buffer for preload
+                                buffer_timeout = getattr(
+                                    args,
+                                    "timeout_buffer",
+                                    getattr(args, "container_timeout_buffer", 60),
                                 )
-                                delete_temporary_files(
-                                    temporary_dir_client=temporary_dir_client,
-                                    full_result_path=None,
-                                    benchmark_tool_global=benchmark_tool_global,
+
+                                res = data_prepopulation_step(
+                                    benchmark_config,
+                                    benchmark_tool_workdir,
+                                    client_cpuset_cpus,
+                                    docker_client,
+                                    git_hash,
+                                    port,
+                                    temporary_dir_client,
+                                    test_name,
+                                    host,
+                                    tls_enabled,
+                                    tls_skip_verify,
+                                    test_tls_cert,
+                                    test_tls_key,
+                                    test_tls_cacert,
+                                    resp_version,
+                                    args.benchmark_local_install,
+                                    password,
+                                    oss_cluster_api_enabled,
+                                    unix_socket,
+                                    buffer_timeout,
+                                    args,
                                 )
-                                continue
+                                if res is False:
+                                    logging.warning(
+                                        "Skipping this test given preload result was false"
+                                    )
+                                    delete_temporary_files(
+                                        temporary_dir_client=temporary_dir_client,
+                                        full_result_path=None,
+                                        benchmark_tool_global=benchmark_tool_global,
+                                    )
+                                    continue
+                    # Send MEMORY PURGE before preload for memory comparison mode (if FLUSHALL wasn't already done)
+                    if memory_comparison_only and not args.flushall_on_every_test_start:
+                        try:
+                            logging.info("Sending MEMORY PURGE before preload for memory comparison mode")
+                            for conn in redis_conns:
+                                conn.execute_command("MEMORY", "PURGE")
+                        except Exception as e:
+                            logging.warning(f"MEMORY PURGE failed before preload: {e}")
+
                     execute_init_commands(
                         benchmark_config, r, dbconfig_keyname="dbconfig"
                     )
@@ -1506,6 +1781,172 @@ def process_self_contained_coordinator_stream(
                         redis_conns,
                     )
 
+                    # For memory comparison mode, collect memory stats after preload and skip client benchmark
+                    if memory_comparison_only:
+                        # Skip load tests (keyspacelen = 0) in memory comparison mode
+                        keyspacelen = benchmark_config.get("dbconfig", {}).get("check", {}).get("keyspacelen", None)
+                        if keyspacelen is not None and keyspacelen == 0:
+                            logging.info(f"Skipping load test {test_name} in memory comparison mode (keyspacelen=0)")
+                            delete_temporary_files(
+                                temporary_dir_client=temporary_dir_client,
+                                full_result_path=None,
+                                benchmark_tool_global=benchmark_tool_global,
+                            )
+                            continue
+
+                        # Handle dry run for memory comparison mode
+                        if dry_run:
+                            dry_run_count = dry_run_count + 1
+                            dry_run_tests.append(test_name)
+                            logging.info(f"[DRY RUN] Would collect memory stats for test {test_name}")
+
+                            # Add dataset info to dry run output
+                            dataset_name = benchmark_config.get("dbconfig", {}).get("dataset_name")
+                            if dataset_name:
+                                logging.info(f"[DRY RUN]   Dataset: {dataset_name}")
+
+                            delete_temporary_files(
+                                temporary_dir_client=temporary_dir_client,
+                                full_result_path=None,
+                                benchmark_tool_global=benchmark_tool_global,
+                            )
+                            continue
+
+                        logging.info(f"Collecting memory stats for test {test_name}")
+                        try:
+                            # Use raw command to avoid parsing issues with some Redis versions
+                            memory_stats_raw = r.execute_command("MEMORY", "STATS")
+                            # Convert list response to dict
+                            memory_stats = {}
+                            for i in range(0, len(memory_stats_raw), 2):
+                                key = memory_stats_raw[i].decode() if isinstance(memory_stats_raw[i], bytes) else str(memory_stats_raw[i])
+                                value = memory_stats_raw[i + 1]
+                                if isinstance(value, bytes):
+                                    try:
+                                        value = float(value.decode())
+                                    except ValueError:
+                                        value = value.decode()
+                                memory_stats[key] = value
+                        except Exception as e:
+                            logging.error(f"Failed to collect memory stats: {e}")
+                            # Fallback to basic memory info
+                            info = r.info("memory")
+                            memory_stats = {
+                                "total.allocated": info.get("used_memory", 0),
+                                "dataset.bytes": info.get("used_memory_dataset", 0),
+                                "keys.count": r.dbsize(),
+                                "keys.bytes-per-key": 0,
+                                "dataset.percentage": 0,
+                                "overhead.total": 0,
+                                "fragmentation": info.get("mem_fragmentation_ratio", 1.0),
+                                "fragmentation.bytes": 0,
+                                "allocator.allocated": info.get("used_memory", 0),
+                                "allocator.resident": info.get("used_memory_rss", 0),
+                                "allocator-fragmentation.ratio": 1.0,
+                            }
+
+                        # Detect object encoding by scanning 1% of the dataset
+                        object_encoding_info = detect_object_encoding(r, benchmark_config.get("dbconfig", {}))
+                        logging.info(f"Object encoding detection: {object_encoding_info.get('encoding', 'unknown')} "
+                                   f"({object_encoding_info.get('confidence', 0)*100:.1f}% confidence)")
+
+                        # Extract key memory metrics
+                        memory_result = {
+                            "test_name": test_name,
+                            "total_allocated": memory_stats.get("total.allocated", 0),
+                            "dataset_bytes": memory_stats.get("dataset.bytes", 0),
+                            "keys_count": memory_stats.get("keys.count", 0),
+                            "keys_bytes_per_key": memory_stats.get("keys.bytes-per-key", 0),
+                            "dataset_percentage": memory_stats.get("dataset.percentage", 0),
+                            "overhead_total": memory_stats.get("overhead.total", 0),
+                            "fragmentation": memory_stats.get("fragmentation", 0),
+                            "fragmentation_bytes": memory_stats.get("fragmentation.bytes", 0),
+                            "allocator_allocated": memory_stats.get("allocator.allocated", 0),
+                            "allocator_resident": memory_stats.get("allocator.resident", 0),
+                            "allocator_fragmentation_ratio": memory_stats.get("allocator-fragmentation.ratio", 0),
+                            # Object encoding information
+                            "object_encoding": object_encoding_info.get("encoding", "unknown"),
+                            "encoding_confidence": object_encoding_info.get("confidence", 0.0),
+                            "encoding_sample_size": object_encoding_info.get("sample_size", 0),
+                            "encoding_distribution": object_encoding_info.get("encoding_distribution", {}),
+                            "encoding_is_complete_scan": object_encoding_info.get("is_complete_scan", False),
+                        }
+                        memory_results.append(memory_result)
+
+                        # Push memory metrics to datasink
+                        if datasink_push_results_redistimeseries:
+                            memory_metrics_dict = {
+                                "memory.total_allocated": memory_result["total_allocated"],
+                                "memory.dataset_bytes": memory_result["dataset_bytes"],
+                                "memory.keys_count": memory_result["keys_count"],
+                                "memory.keys_bytes_per_key": memory_result["keys_bytes_per_key"],
+                                "memory.dataset_percentage": memory_result["dataset_percentage"],
+                                "memory.overhead_total": memory_result["overhead_total"],
+                                "memory.fragmentation": memory_result["fragmentation"],
+                                "memory.fragmentation_bytes": memory_result["fragmentation_bytes"],
+                                "memory.allocator_allocated": memory_result["allocator_allocated"],
+                                "memory.allocator_resident": memory_result["allocator_resident"],
+                                "memory.allocator_fragmentation_ratio": memory_result["allocator_fragmentation_ratio"],
+                                "memory.encoding_confidence": memory_result["encoding_confidence"],
+                                "memory.encoding_sample_size": memory_result["encoding_sample_size"],
+                            }
+
+                            # Add object encoding to metadata
+                            metadata["object_encoding"] = memory_result["object_encoding"]
+                            metadata["encoding_confidence"] = f"{memory_result['encoding_confidence']:.3f}"
+                            metadata["encoding_sample_size"] = str(memory_result["encoding_sample_size"])
+                            metadata["encoding_scan_type"] = "complete" if memory_result.get("encoding_is_complete_scan", False) else "sample"
+
+                            # Add encoding distribution to metadata if multiple encodings found
+                            if len(memory_result["encoding_distribution"]) > 1:
+                                for enc, percentage in memory_result["encoding_distribution"].items():
+                                    metadata[f"encoding_dist_{enc}"] = f"{percentage:.1f}%"
+
+                            # Set datapoint_time_ms for memory comparison mode
+                            datapoint_time_ms = start_time_ms
+
+                            exporter_datasink_common(
+                                benchmark_config,
+                                0,  # benchmark_duration_seconds = 0 for memory only
+                                build_variant_name,
+                                datapoint_time_ms,
+                                dataset_load_duration_seconds,
+                                datasink_conn,
+                                datasink_push_results_redistimeseries,
+                                git_branch,
+                                git_version,
+                                metadata,
+                                redis_conns,
+                                memory_metrics_dict,
+                                running_platform,
+                                args.deployment_name,
+                                args.deployment_type,
+                                test_name,
+                                tf_github_org,
+                                tf_github_repo,
+                                tf_triggering_env,
+                                topology_spec_name,
+                                default_metrics,
+                                git_hash,
+                            )
+
+                        # Send MEMORY PURGE after memory comparison (if FLUSHALL at test end is not enabled)
+                        if not args.flushall_on_every_test_end:
+                            try:
+                                logging.info("Sending MEMORY PURGE after memory comparison")
+                                for conn in redis_conns:
+                                    conn.execute_command("MEMORY", "PURGE")
+                            except Exception as e:
+                                logging.warning(f"MEMORY PURGE failed after memory comparison: {e}")
+
+                        logging.info(f"Memory comparison completed for test {test_name}")
+                        delete_temporary_files(
+                            temporary_dir_client=temporary_dir_client,
+                            full_result_path=None,
+                            benchmark_tool_global=benchmark_tool_global,
+                        )
+                        continue
+
                     if dry_run_include_preload is True:
                         dry_run_count = dry_run_count + 1
                         dry_run_tests.append(test_name)
@@ -2070,6 +2511,19 @@ def process_self_contained_coordinator_stream(
                         for r in redis_conns:
                             r.flushall()
 
+                        # Send MEMORY PURGE after FLUSHALL for memory comparison mode
+                        if memory_comparison_only:
+                            try:
+                                logging.info("Sending MEMORY PURGE after FLUSHALL at test end")
+                                for r in redis_conns:
+                                    r.execute_command("MEMORY", "PURGE")
+                            except Exception as e:
+                                logging.warning(f"MEMORY PURGE failed after FLUSHALL at test end: {e}")
+
+                except KeyboardInterrupt:
+                    logging.info("KeyboardInterrupt caught. Exiting...")
+                    print("\nKeyboardInterrupt caught. Exiting...")
+                    break
                 except:
                     logging.critical(
                         "Some unexpected exception was caught "
@@ -2080,6 +2534,11 @@ def process_self_contained_coordinator_stream(
                     traceback.print_exc(file=sys.stdout)
                     print("-" * 60)
                     test_result = False
+
+                    # Check if user requested exit via Ctrl+C
+                    if _exit_requested:
+                        logging.info("Exit requested by user. Stopping after exception.")
+                        break
                 # tear-down
                 logging.info("Tearing down setup")
                 for container in client_containers:
@@ -2114,6 +2573,11 @@ def process_self_contained_coordinator_stream(
                     benchmark_tool_global=benchmark_tool_global,
                 )
 
+    # Check if user requested exit via Ctrl+C
+    if _exit_requested:
+        logging.info("Exit requested by user. Printing summary before exit.")
+        print("\nExecution stopped by user request. Printing summary of completed tests...")
+
     # Print Redis server information section before results
     if len(results_matrix) > 0:
         # Get redis_conns from the first test context (we need to pass it somehow)
@@ -2136,6 +2600,10 @@ def process_self_contained_coordinator_stream(
     )
     writer.write_table()
 
+    # Add note if execution was stopped early
+    if _exit_requested:
+        print("\n(Note: Execution was stopped early by user request - showing results for completed tests only)")
+
     if client_aggregated_results_folder != "":
         os.makedirs(client_aggregated_results_folder, exist_ok=True)
         dest_fpath = f"{client_aggregated_results_folder}/aggregate-results.csv"
@@ -2148,15 +2616,112 @@ def process_self_contained_coordinator_stream(
         )
         csv_writer.dump(dest_fpath)
 
+    # Print memory comparison summary if in memory comparison mode
+    if memory_comparison_only and memory_results:
+        logging.info("\n" + "="*80)
+        logging.info("MEMORY COMPARISON SUMMARY")
+        logging.info("="*80)
+        logging.info(f"Total unique datasets loaded: {len(loaded_datasets)}")
+        if loaded_datasets:
+            logging.info(f"Datasets: {', '.join(sorted(loaded_datasets))}")
+        logging.info("="*80)
+
+        # Create memory summary table
+        memory_headers = [
+            "Test Name",
+            "Total Allocated",
+            "Dataset Bytes",
+            "Keys Count",
+            "Bytes/Key",
+            "Dataset %",
+            "Overhead",
+            "Fragmentation",
+            "Alloc Fragmentation",
+            "Object Encoding",
+            "Encoding Confidence",
+            "Scan Type"
+        ]
+
+        memory_matrix = []
+        for result in memory_results:
+            # Convert bytes to human readable format
+            total_mb = result["total_allocated"] / (1024 * 1024)
+            dataset_mb = result["dataset_bytes"] / (1024 * 1024)
+            overhead_mb = result["overhead_total"] / (1024 * 1024)
+
+            memory_matrix.append([
+                result["test_name"],
+                f"{total_mb:.1f}MB",
+                f"{dataset_mb:.1f}MB",
+                f"{result['keys_count']:,}",
+                f"{result['keys_bytes_per_key']:.0f}B",
+                f"{result['dataset_percentage']:.1f}%",
+                f"{overhead_mb:.1f}MB",
+                f"{result['fragmentation']:.2f}",
+                f"{result['allocator_fragmentation_ratio']:.3f}",
+                result.get("object_encoding", "unknown"),
+                f"{result.get('encoding_confidence', 0.0)*100:.1f}%",
+                "complete" if result.get("encoding_is_complete_scan", False) else "sample"
+            ])
+
+        memory_writer = MarkdownTableWriter(
+            table_name="Memory Usage Summary",
+            headers=memory_headers,
+            value_matrix=memory_matrix,
+        )
+        memory_writer.write_table()
+
     if dry_run is True:
+        mode_description = "memory comparison" if memory_comparison_only else "benchmark"
         logging.info(
-            "Number of tests that would have been run: {}".format(dry_run_count)
+            "Number of tests that would have been run ({}): {}".format(mode_description, dry_run_count)
         )
+        if _exit_requested:
+            logging.info("(Note: Execution was stopped early by user request)")
         if dry_run_tests:
-            logging.info("Tests that would be run:")
+            logging.info(f"Tests that would be run ({mode_description} mode):")
+            for test in dry_run_tests:
+                logging.info(f"  - {test}")
             final_test_regex = "|".join(dry_run_tests)
             logging.info(f"Final test regex: {final_test_regex}")
 
+            # For memory comparison mode, show dataset analysis
+            if memory_comparison_only:
+                unique_datasets = set()
+                tests_with_datasets = 0
+
+                for test_file in testsuite_spec_files:
+                    if defaults_filename in test_file:
+                        continue
+                    try:
+                        with open(test_file, "r") as stream:
+                            benchmark_config = yaml.safe_load(stream)
+
+                        test_name = extract_test_name_from_test_configuration_file(test_file)
+                        if test_name in dry_run_tests and "dbconfig" in benchmark_config:
+                            # Skip load tests in dry run analysis too
+                            keyspacelen = benchmark_config["dbconfig"].get("check", {}).get("keyspacelen", None)
+                            if keyspacelen is not None and keyspacelen == 0:
+                                continue
+
+                            dataset_name = benchmark_config["dbconfig"].get("dataset_name")
+                            if dataset_name:
+                                unique_datasets.add(dataset_name)
+                                tests_with_datasets += 1
+
+                    except Exception as e:
+                        logging.debug(f"Error analyzing {test_file} for dry run: {e}")
+
+                if tests_with_datasets > 0:
+                    logging.info(f"\nMemory comparison analysis:")
+                    logging.info(f"  Tests with datasets: {tests_with_datasets}")
+                    logging.info(f"  Unique datasets: {len(unique_datasets)}")
+                    logging.info(f"  Dataset ingestion savings: {tests_with_datasets - len(unique_datasets)} skipped loads")
+                    if unique_datasets:
+                        logging.info(f"  Datasets that would be loaded:")
+                        for dataset in sorted(unique_datasets):
+                            logging.info(f"    - {dataset}")
+
 
 def get_maxmemory(r):
     memory_info = r.info("memory")