|
| 1 | +import os, re |
| 2 | +import pandas as pd |
| 3 | +from io import StringIO |
| 4 | + |
| 5 | + |
| 6 | +def parse_time_avg(path): |
| 7 | + last_val = None |
| 8 | + pattern = re.compile(r"Time Avg =\s*([0-9.E+-]+)") |
| 9 | + with open(path) as f: |
| 10 | + for line in f: |
| 11 | + match = pattern.search(line) |
| 12 | + if match: |
| 13 | + last_val = float(match.group(1)) |
| 14 | + return last_val |
| 15 | + |
| 16 | + |
| 17 | +def parse_grind_time(path): |
| 18 | + last_val = None |
| 19 | + pattern = re.compile(r"Performance: \s*([0-9.E+-]+)") |
| 20 | + with open(path) as f: |
| 21 | + for line in f: |
| 22 | + match = pattern.search(line) |
| 23 | + if match: |
| 24 | + last_val = float(match.group(1)) |
| 25 | + return last_val |
| 26 | + |
| 27 | + |
| 28 | +def parse_reference_file(filename): |
| 29 | + with open(filename) as f: |
| 30 | + content = f.read() |
| 31 | + |
| 32 | + records = [] |
| 33 | + blocks = re.split(r"\n(?=Weak|Strong|Grind)", content.strip()) |
| 34 | + |
| 35 | + for block in blocks: |
| 36 | + lines = block.strip().splitlines() |
| 37 | + header = lines[0].strip() |
| 38 | + body = "\n".join(lines[1:]) |
| 39 | + |
| 40 | + df = pd.read_csv(StringIO(body), delim_whitespace=True) |
| 41 | + |
| 42 | + if header.startswith("Weak Scaling"): |
| 43 | + # Parse metadata from header |
| 44 | + mem_match = re.search(r"Memory: ~(\d+)GB", header) |
| 45 | + rdma_match = re.search(r"RDMA: (\w)", header) |
| 46 | + memory = int(mem_match.group(1)) if mem_match else None |
| 47 | + rdma = rdma_match.group(1) if rdma_match else None |
| 48 | + |
| 49 | + for _, row in df.iterrows(): |
| 50 | + records.append({"scaling": "weak", "nodes": int(row["nodes"]), "memory": memory, "rdma": rdma, "phase": "sim", "time_avg": row["time_avg"], "efficiency": row["efficiency"]}) |
| 51 | + |
| 52 | + elif header.startswith("Strong Scaling"): |
| 53 | + mem_match = re.search(r"Memory: ~(\d+)GB", header) |
| 54 | + rdma_match = re.search(r"RDMA: (\w)", header) |
| 55 | + memory = int(mem_match.group(1)) if mem_match else None |
| 56 | + rdma = rdma_match.group(1) if rdma_match else None |
| 57 | + |
| 58 | + for _, row in df.iterrows(): |
| 59 | + records.append( |
| 60 | + { |
| 61 | + "scaling": "strong", |
| 62 | + "nodes": int(row["nodes"]), |
| 63 | + "memory": memory, |
| 64 | + "rdma": rdma, |
| 65 | + "phase": "sim", |
| 66 | + "time_avg": row["time_avg"], |
| 67 | + "speedup": row["speedup"], |
| 68 | + "efficiency": row["efficiency"], |
| 69 | + } |
| 70 | + ) |
| 71 | + |
| 72 | + elif header.startswith("Grind Time"): |
| 73 | + for _, row in df.iterrows(): |
| 74 | + records.append({"scaling": "grind", "memory": int(row["memory"]), "grind_time": row["grind_time"]}) |
| 75 | + |
| 76 | + return pd.DataFrame(records) |
| 77 | + |
| 78 | + |
| 79 | +# Get log files and filter for simulation logs |
| 80 | +files = os.listdir("examples/scaling/logs/") |
| 81 | +files = [f for f in files if "sim" in f] |
| 82 | + |
| 83 | +records = [] |
| 84 | +for fname in files: |
| 85 | + # Remove extension |
| 86 | + parts = fname.replace(".out", "").split("-") |
| 87 | + scaling, nodes, memory, rdma, phase = parts |
| 88 | + records.append({"scaling": scaling, "nodes": int(nodes), "memory": int(memory), "rdma": rdma, "phase": phase, "file": fname}) |
| 89 | + |
| 90 | +df = pd.DataFrame(records) |
| 91 | + |
| 92 | +ref_data = parse_reference_file("examples/scaling/reference.dat") |
| 93 | + |
| 94 | +print() |
| 95 | + |
| 96 | +weak_df = df[df["scaling"] == "weak"] |
| 97 | +strong_df = df[df["scaling"] == "strong"] |
| 98 | +grind_df = df[df["scaling"] == "grind"] |
| 99 | + |
| 100 | +weak_ref_df = ref_data[ref_data["scaling"] == "weak"] |
| 101 | +strong_ref_df = ref_data[ref_data["scaling"] == "strong"] |
| 102 | +grind_ref_df = ref_data[ref_data["scaling"] == "grind"] |
| 103 | + |
| 104 | +weak_scaling_mem = weak_df["memory"].unique() |
| 105 | +weak_scaling_rdma = weak_df["rdma"].unique() |
| 106 | + |
| 107 | +for mem in weak_scaling_mem: |
| 108 | + for rdma in weak_scaling_rdma: |
| 109 | + subset = weak_df[(weak_df["memory"] == mem) & (weak_df["rdma"] == rdma)] |
| 110 | + subset = subset.sort_values(by="nodes") |
| 111 | + ref = weak_ref_df[(weak_ref_df["memory"] == mem) & (weak_ref_df["rdma"] == rdma) & (weak_ref_df["nodes"].isin(subset["nodes"]))] |
| 112 | + ref = ref.sort_values(by="nodes") |
| 113 | + |
| 114 | + times = [] |
| 115 | + for _, row in subset.iterrows(): |
| 116 | + time_avg = parse_time_avg(os.path.join("examples/scaling/logs", row["file"])) |
| 117 | + times.append(time_avg) |
| 118 | + |
| 119 | + subset = subset.copy() |
| 120 | + ref = ref.copy() |
| 121 | + subset["time_avg"] = times |
| 122 | + base_time = subset.iloc[0]["time_avg"] |
| 123 | + |
| 124 | + subset["efficiency"] = base_time / subset["time_avg"] |
| 125 | + subset["rel_perf"] = subset["time_avg"] / ref["time_avg"].values |
| 126 | + print(f"Weak Scaling - Memory: ~{mem}GB, RDMA: {rdma}") |
| 127 | + print(subset[["nodes", "time_avg", "efficiency", "rel_perf"]].to_string(index=False)) |
| 128 | + print() |
| 129 | + |
| 130 | +strong_scaling_mem = strong_df["memory"].unique() |
| 131 | +strong_scaling_rdma = strong_df["rdma"].unique() |
| 132 | + |
| 133 | +for mem in strong_scaling_mem: |
| 134 | + for rdma in strong_scaling_rdma: |
| 135 | + subset = strong_df[(strong_df["memory"] == mem) & (strong_df["rdma"] == rdma)] |
| 136 | + subset = subset.sort_values(by="nodes") |
| 137 | + |
| 138 | + ref = strong_ref_df[(strong_ref_df["memory"] == mem) & (strong_ref_df["rdma"] == rdma) & (strong_ref_df["nodes"].isin(subset["nodes"]))] |
| 139 | + ref = ref.sort_values(by="nodes") |
| 140 | + |
| 141 | + times = [] |
| 142 | + for _, row in subset.iterrows(): |
| 143 | + time_avg = parse_time_avg(os.path.join("examples/scaling/logs", row["file"])) |
| 144 | + times.append(time_avg) |
| 145 | + |
| 146 | + subset = subset.copy() |
| 147 | + ref = ref.copy() |
| 148 | + subset["time_avg"] = times |
| 149 | + base_time = subset.iloc[0]["time_avg"] |
| 150 | + |
| 151 | + subset["speedup"] = base_time / subset["time_avg"] |
| 152 | + subset["efficiency"] = base_time / ((subset["nodes"] / subset.iloc[0]["nodes"]) * subset["time_avg"]) |
| 153 | + subset["rel_perf"] = subset["time_avg"] / ref["time_avg"].values |
| 154 | + print(f"Strong Scaling - Memory: ~{mem}GB, RDMA: {rdma}") |
| 155 | + print(subset[["nodes", "time_avg", "speedup", "efficiency", "rel_perf"]].to_string(index=False)) |
| 156 | + print() |
| 157 | + |
| 158 | +if not grind_df.empty: |
| 159 | + grind_mem = grind_df["memory"].unique() |
| 160 | + subset = grind_df.sort_values(by="memory") |
| 161 | + ref = grind_ref_df[(grind_ref_df["memory"].isin(subset["memory"]))] |
| 162 | + ref = ref.sort_values(by="memory") |
| 163 | + |
| 164 | + times = [] |
| 165 | + for _, row in subset.iterrows(): |
| 166 | + grind_time = parse_grind_time(os.path.join("examples/scaling/logs", row["file"])) |
| 167 | + times.append(grind_time) |
| 168 | + |
| 169 | + subset = subset.copy() |
| 170 | + ref = ref.copy() |
| 171 | + |
| 172 | + subset["grind_time"] = times |
| 173 | + subset["rel_perf"] = subset["grind_time"] / ref["grind_time"].values |
| 174 | + print(f"Grind Time - Single Device") |
| 175 | + print(subset[["memory", "grind_time", "rel_perf"]].to_string(index=False)) |
| 176 | + |
| 177 | +print() |
0 commit comments