update cache analysis

Author: owenlly

benchmark/basic_performance/build/utils/build_utils.py

@@ -104,13 +104,13 @@ def load_global_env():
 def clean(build_dir: Path, sudo: bool = False):
     build_dir = build_dir.resolve()
     if os.path.exists(build_dir):
-        run(f"rm -rf {build_dir}", sudo=sudo)
+        run(f"rm -rf {build_dir}", sudo=True)
 
 
 def make_build_dir(build_dir, sudo: bool = False):
     build_dir = build_dir.resolve()
     if not os.path.exists(build_dir):
-        run(f"mkdir -p {build_dir}", sudo=sudo)
+        run(f"mkdir -p {build_dir}", sudo=True)
 
 
 def get_threads_num():
@@ -131,6 +131,7 @@ def run_cmake(build_dir: Path, arch: str, sudo: bool = False):
             raise ValueError(f"Unknown machine type: {arch}")
         core_num_per_socket = get_cpu_number(arch)
         socket_num = get_socket_number(arch)
+        print(f"machine_type: {machine_type}, core_num_per_socket: {core_num_per_socket}, socket_num: {socket_num}")
         run(
             " ".join(
                 [
@@ -140,16 +141,16 @@ def run_cmake(build_dir: Path, arch: str, sudo: bool = False):
                     f"-DMAX_SOCKET_NUM={socket_num}"
                 ]
             ),
-            sudo=sudo,
+            sudo=True,
             pty=True,
         )
         numbers = get_threads_num()
-        run(f"cmake --build . -j{numbers}", sudo=sudo)
+        run(f"cmake --build . -j{numbers}", sudo=True)
 
 
 def run_build(build_dir: Path, arch, sudo=False):
     build_dir = build_dir.resolve()
 
-    clean(build_dir, sudo=sudo)
-    make_build_dir(build_dir, sudo=sudo)
-    run_cmake(build_dir, arch, sudo=sudo)
+    clean(build_dir, sudo=True)
+    make_build_dir(build_dir, sudo=True)
+    run_cmake(build_dir, arch, sudo=True)

benchmark/basic_performance/env_files/agamotto.env

@@ -1,4 +1,7 @@
 disable_prefetch=True
 boost_cpu=True
-dimm_physical_start_addr = 0x800000000
-dimm_test_size=0x840000000
+dimm_physical_start_addr=0x800000000 # 32GB
+cxl_physical_start_addr=0x4080000000 # 258GB
+test_size=0x840000000 # 32GB test buffer + 1GB cindex buffer
+socket_number=2
+snc_mode=1

benchmark/basic_performance/env_files/hulk.env

@@ -1,4 +1,7 @@
-disable_prefetch=False
+disable_prefetch=True
 boost_cpu=True
-dimm_physical_start_addr=0x200000000
-dimm_test_size=0x840000000
+dimm_physical_start_addr=0x800000000 # 32GB
+cxl_physical_start_addr=0x2080000000 # 130GB
+test_size=0x840000000 # 32GB test buffer + 1GB cindex buffer
+socket_number=2
+snc_mode=1

benchmark/basic_performance/env_files/stormbreaker.env

@@ -1,4 +1,7 @@
 disable_prefetch=True
 boost_cpu=True
-dimm_physical_start_addr=0x800000000
-dimm_test_size=0x840000000
+dimm_physical_start_addr=0x800000000 # 32GB
+cxl_physical_start_addr=0x4080000000 # 258GB
+test_size=0x840000000 # 32GB test buffer + 1GB cindex buffer
+socket_number=2
+snc_mode=1

benchmark/basic_performance/scripts/batch/200_cache_heatmap.yaml

@@ -1,17 +1,23 @@
 job_id: 200 # enum class JobId : uint32_t  @ src/core/system_define.h
-repeat: [32]
-core_id: [0]
-node_id: [0]
-use_flush: [0]
-access_order: [0]
-stride_size_array: [0x40, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000,
-                    0x4000, 0x8000, 0x10000, 0x20000, 0x40000, 0x80000,
-                    0x100000, 0x200000, 0x400000, 0x800000, 0x1000000,
-                    0x2000000, 0x4000000] # 64B ~ 64MB
-#stride_size_array: [0x40] # 64B
-block_num_array: [0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80, 0x100, 0x200,
-                  0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000, 0x10000,
-                  0x20000, 0x40000, 0x80000, 0x100000] # 1 ~ 1M
-#block_num_array: [0x1] # 1
-test_size_array: [0x800000000] # 32GB
-test_idx_array: [0x0]
+test_type: 0 # 0: measure access latency, 1: measure flush latency
+repeat: 32
+use_flush: 1 # 0: no flush, 1: use flush after one round of access
+core_id: [0, 20] # two cores on the different sockets
+node_id: [2] # access memory on node_id
+flush_type: [0] # 0: clflush, 1: clflushopt, 2: clwb
+ldst_type: [0] # 0: temporal # TODO: add support for 1: non-temporal, 2: atomic
+access_order: [0] # 0: random, 1: sequential
+stride_size_array: [0x40, 0x80, 0x100, 0x200, 
+                    0x400, 0x800, 0x1000, 0x2000,
+                    0x4000, 0x8000, 0x10000, 0x20000, 
+                    0x40000, 0x80000, 0x100000, 0x200000,
+                    0x400000, 0x800000, 0x1000000, 0x2000000,
+                    0x4000000] # 64B to 64MB
+# stride_size_array: [0x40]
+block_num_array: [0x1, 0x2, 0x4, 0x8,
+                  0x10, 0x20, 0x40, 0x80,
+                  0x100, 0x200, 0x400, 0x800,
+                  0x1000, 0x2000, 0x4000, 0x8000,
+                  0x10000, 0x20000, 0x40000, 0x80000,
+                  0x100000] # 1 to 1MB
+# block_num_array: [0x1]

…erformance/scripts/parse/cache_parser.py …performance/scripts/plot/heatmap_plot.pybenchmark/basic_performance/scripts/parse/cache_parser.py renamed to benchmark/basic_performance/scripts/plot/heatmap_plot.py benchmark/basic_performance/scripts/parse/cache_parser.py renamed to benchmark/basic_performance/scripts/plot/heatmap_plot.py

@@ -1,9 +1,9 @@
 #
 # MIT License
 #
-# Copyright (c) 2025 Jangseon Park
+# Copyright (c) 2025 Jangseon Park, Luyi Li
 # Affiliation: University of California San Diego CSE
-# Email: jap036@ucsd.edu
+# Email: jap036@ucsd.edu, lul@014@ucsd.edu
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -36,7 +36,7 @@
 
 # Function to read log data from a file
 def read_log_file(file_path):
-    with open(file_path) as file:
+    with open(file_path, "r") as file:
         return file.read()
 
 
@@ -48,36 +48,58 @@ def parse_pattern(base_dir):
     store_latency_ns_list = []
     load_latency_cycle_list = []
     load_latency_ns_list = []
+    access_order_list = []
+    snc_mode_list = []
+    core_id_list = []
+    node_id_list = []
+    ldst_type_list = []
 
     index = 0
     for root, _, files in os.walk(base_dir):
         if "result.log" in files:
             log_path = os.path.join(root, "result.log")
-            with open(log_path) as f:
+            with open(log_path, "r") as f:
                 content = f.read()
                 test_info = re.search(
-                    r"==========Test No.==========\n"
-                    r"Number of block: (\d+)\n"
-                    r"Stride Size: (\d+)\n"
-                    r"Average store time:\s+(\d+)\s+cycles,\s+([\d\.]+)\s+ns\n"
-                    r"Average load time:\s+(\d+)\s+cycles,\s+([\d\.]+)\s+ns",
+                    r"=============== Test Information ===============.*?"
+                    r"Number of Block:\s+(\d+).*?"
+                    r"Stride Size:\s+(\d+).*?"
+                    r"SNC Mode:\s+(\d+).*?"
+                    r"Core ID:\s+(\d+).*?"
+                    r"Node ID:\s+(\d+).*?"
+                    r"Access Order:\s+(\w+).*?"
+                    r"Load/Store Type:\s+(\w+).*?"
+                    r"=============== Test Results ===============.*?"
+                    r"Average Store Latency:\s+(\d+)\s+cycles,\s+([\d.]+)\s+ns.*?"
+                    r"Average Load Latency:\s+(\d+)\s+cycles,\s+([\d.]+)\s+ns",
                     content,
+                    re.DOTALL  # Use DOTALL instead of MULTILINE to match across lines
                 )
                 if test_info:
                     (
                         block_num,
                         stride_size,
+                        snc_mode,
+                        core_id,
+                        node_id,
+                        access_order,
+                        ldst_type,
                         store_lat_cycle,
                         store_lat_ns,
                         load_lat_cycle,
                         load_lat_ns,
                     ) = test_info.groups()
-
+                    
                     logger.info(
                         ", ".join(
                             [
                                 f"Block Num: {block_num}",
                                 f"Stride Size: {stride_size}",
+                                f"SNC Mode: {snc_mode}",
+                                f"Core ID: {core_id}",
+                                f"Node ID: {node_id}",
+                                f"Access Order: {access_order}",
+                                f"Load/Store Type: {ldst_type}",
                                 f"Store Latency Cycle: {store_lat_cycle}",
                                 f"Store Latency ns: {store_lat_ns}",
                                 f"Load Latency Cycle: {load_lat_cycle}",
@@ -89,6 +111,11 @@ def parse_pattern(base_dir):
                     test_index.append(index)
                     block_result.append(int(block_num))
                     stride_result.append(int(stride_size))
+                    snc_mode_list.append(int(snc_mode))
+                    core_id_list.append(int(core_id))
+                    node_id_list.append(int(node_id))
+                    access_order_list.append(access_order)
+                    ldst_type_list.append(ldst_type)
                     store_latency_cycle_list.append(int(store_lat_cycle))
                     store_latency_ns_list.append(float(store_lat_ns))
                     load_latency_cycle_list.append(int(load_lat_cycle))
@@ -99,6 +126,11 @@ def parse_pattern(base_dir):
         test_index,
         block_result,
         stride_result,
+        snc_mode_list,
+        core_id_list,
+        node_id_list,
+        access_order_list,
+        ldst_type_list,
         store_latency_cycle_list,
         store_latency_ns_list,
         load_latency_cycle_list,
@@ -112,6 +144,11 @@ def parse_results(log_file_path):
         test_index,
         block_num,
         stride_size,
+        snc_mode,
+        core_id,
+        node_id,
+        access_order,
+        ldst_type,
         store_latency_cycle,
         store_latency_ns,
         load_latency_cycle,
@@ -120,40 +157,18 @@ def parse_results(log_file_path):
 
     # Initialize an empty list to store the parsed data
     data = []
-
-    # Regex patterns to capture relevant information
-    # test_pattern = r"==========Test No\.(\d+)=========="
-    # block_pattern = r"Number of block: (\d+)"
-    # stride_pattern = r"Stride Size: (\d+)"
-    # store_pattern = r"Average store time:\s+(\d+)\s+cycles,\s+([\d\.]+)\s+ns"
-    # load_pattern = r"Average load time:\s+(\d+)\s+cycles,\s+([\d\.]+)\s+ns"
-
-    # Parse the log data
-    # test_index = re.findall(test_pattern, log_data)
-    # block_num = re.findall(block_pattern, log_data)
-    # stride_size = re.findall(stride_pattern, log_data)
-    # store_results = re.findall(store_pattern, log_data)
-    # load_results = re.findall(load_pattern, log_data)
-
-    # store_latency_cycle = []
-    # store_latency_ns = []
-    # for store_result in store_results:
-    #    store_latency_cycle.append(store_result[0])
-    #    store_latency_ns.append(store_result[1])
-
-    # load_latency_cycle = []
-    # load_latency_ns = []
-    # for load_result in load_results:
-    #    load_latency_cycle.append(load_result[0])
-    #    load_latency_ns.append(load_result[1])
-
     # Store the parsed data in a list
     for i in range(len(test_index)):
         data.append(
             {
                 "test_index": int(test_index[i]),
                 "block_num": int(block_num[i]),
                 "stride_size": int(stride_size[i]),
+                "snc_mode": int(snc_mode[i]),
+                "core_id": int(core_id[i]),
+                "node_id": int(node_id[i]),
+                "access_order": access_order[i],
+                "ldst_type": ldst_type[i],
                 "store_latency_cycle": int(store_latency_cycle[i]),
                 "load_latency_cycle": int(load_latency_cycle[i]),
                 "store_latency_ns": int(store_latency_ns[i]),
@@ -168,14 +183,14 @@ def parse_results(log_file_path):
 
 def format_label(value):
     if value >= 2**20:
-        return f"{int(value / 2**20)}M"
+        return f"{int(value / 2 ** 20)}M"
     elif value >= 2**10:
-        return f"{int(value / 2**10)}K"
+        return f"{int(value / 2 ** 10)}K"
     else:
         return str(value)
 
 
-def plot_heatmap(df, access_op, base_dir):
+def plot_heatmap(base_dir, df, access_op, snc_mode, core_id, node_id, access_order, ldst_type):
     if access_op == "load":
         pivot_table_value = "load_latency_ns"
     elif access_op == "store":
@@ -197,22 +212,41 @@ def plot_heatmap(df, access_op, base_dir):
     pivot_table = pivot_table.iloc[::-1]
 
     plt.figure(figsize=(10, 10))
-    ax = sns.heatmap(pivot_table, annot=False, cmap="plasma")
+    ax = sns.heatmap(pivot_table, annot=False, cmap="plasma", vmin=0, vmax=800)
 
     ax.set_xticks(np.arange(len(x_ticks)))
     ax.set_xticklabels([format_label(tick) for tick in x_ticks])
     ax.set_yticks(np.arange(len(y_ticks)))
     ax.set_yticklabels([format_label(tick) for tick in reversed(y_ticks)])
 
-    plt.title(f"heatmap_{access_op}")
+    # plt.title(f"heatmap_{access_op}")
     plt.xlabel("Stride Size (Byte)")
     plt.ylabel("Number of Blocks")
-    plt.savefig(f"{base_dir}/heatmap_{access_op}.pdf")
+    plt.savefig(f"{base_dir}/heatmap_{access_op}_snc{snc_mode}_core{core_id}_node{node_id}_{access_order}_{ldst_type}.pdf")
     plt.close()
 
 
-def parse_and_plot(base_dir):
+def parse_plot_heatmap(base_dir):
     results_df = parse_results(base_dir)
     results_df.to_csv(f"{base_dir}/results.csv", index=False)
-    plot_heatmap(results_df, "load", base_dir)
-    plot_heatmap(results_df, "store", base_dir)
+    snc_modes = results_df['snc_mode'].unique()
+    core_ids = results_df['core_id'].unique()
+    node_ids = results_df['node_id'].unique()
+    access_orders = results_df['access_order'].unique()
+    ldst_types = results_df['ldst_type'].unique()
+    for snc_mode in snc_modes:
+        for core_id in core_ids:
+            for node_id in node_ids:
+                for access_order in access_orders:
+                    for ldst_type in ldst_types:
+                        filtered_df = results_df[
+                            (results_df["snc_mode"] == snc_mode)
+                            & (results_df["core_id"] == core_id)
+                            & (results_df["node_id"] == node_id)
+                            & (results_df["access_order"] == access_order)
+                            & (results_df["ldst_type"] == ldst_type)
+                        ]
+                        if not filtered_df.empty:
+                            plot_heatmap(base_dir, filtered_df, "load", snc_mode, core_id, node_id, access_order, ldst_type)
+                            plot_heatmap(base_dir, filtered_df, "store", snc_mode, core_id, node_id, access_order, ldst_type)
+