cache_utils/analyse_csv.py

@@ -163,7 +163,6 @@ columns = [
     ("helper_core_fixed", "helper_core", "core"),
     ("helper_ht", "helper_core", "hthread"),
 ]
-if not args.stats:
 for (col, icol, key) in columns:
     df[col] = df[icol].apply(remap_core(key))
     print_timed(f"Column {col} added")
@@ -245,7 +244,7 @@ def export_stats_csv():
         """
         Compute the statistic for 1 helper core/main core/slice/column
         - median : default, not influenced by errors
-        - average : better precision when observing floor steps in the results
+        - average : better accuracy when observing floor steps in the results
         """
         # return wq.median(x["time"], x[key])
         return np.average(x[key], weights=x["time"])

cache_utils/analyse_medians.py

@@ -177,76 +177,44 @@ num_core = len(stats["main_core_fixed"].unique())/2
 def ring_distance(x0, x1):
     """
     return (a, b) where `a` is the core distance and `b` the larger "ring step"
-    it is possible that going from 0->7 costs one more than 3->4
     """
     dist = abs(x0-x1)
     if x0 // (num_core/2) != x1 // (num_core/2):
-        # côté du coeur différent
+        return min(num_core-1-dist, dist-1), 1
-        return min((num_core-1-dist, 2), (dist-1, 1))
     else:
         return dist, 0
 
-def slice_msg_distance(source, dest):
+def slice_msg_distance(x1, x0):
     """
     Si l'expéditeur est à l'extrémité d'une des lignes, il envoie toujours dans le même sens
     (vers toute sa ligne d'abord), sinon, il prend le chemin le plus court
-    le bonus correspond au fait que 0->7 puisse coûter 1 de plus que 3->4
     """
-    dist = abs(source-dest)
+    dist = abs(x0-x1)
-    if source // (num_core/2) == dest // (num_core/2):
+    if x0 == 3:
-        return (dist, 0)
+        dist = (x0-x1+8)%8
+    elif x0 == 4:
+        dist = (x1-x0+8)%8
 
-    # Pour aller de l'autre côté
+    if x0 in [0, 3, 4, 7]:
-    up, down = (num_core-1-dist, 2), (dist-1, 1)
+        if dist > 3:
-    if source in [0, 7]:
+            return dist, 1
-        return down
+        return dist, 0
-    if source in [3, 4] or source in [2, 5]:
-        return up
-    if source in [1, 6]:
-        return min(up, down)
 
-    raise IndexError
+    return ring_distance(x0, x1)
 
-def ha_dist(core, is_QPI):
-    """
-    distance to Home Agent
-    """
-    if is_QPI:
-        if core < 4:
-            return core
-        return 7-core
 
-    if core < 4:
+def miss_topology(main_core, slice_group, C, h, H):
-        return 3-core
+    core, ring = slice_msg_distance(main_core, slice_group)
-    return core-4
+    return C + h * core + H*ring
 
-def cclockwise_ha_dist(core, is_QPI):
+def miss_topology_df(x, C, h, H):
-    """
+    func = lambda x, C, h, H: miss_topology(x["main_core_fixed"], x["slice_group"], C, h, H)
-    counter-clockwise distance to Home Agent
+    return x.apply(func, args=(C, h, H), axis=1)
-    """
-    if is_QPI:
-        return 7-core
-
-    if core < 4:
-        return 3-core
-    return 11-core
-
-def miss_topology(main_core, slice_group, h, down_jump, top_jump, ini, ha_h):
-    core, ring = slice_msg_distance(slice_group, main_core%8)
-
-    side_jump = 0
-    side_jump += top_jump if ring == 2 else 0
-    side_jump += down_jump if ring == 1 else 0
-    return (cclockwise_ha_dist(slice_group, False)//2)*ha_h+h*core + side_jump + ini
-
-def miss_topology_df(x, h, down_jump, top_jump, ini, ha_h):
-    func = lambda x, h, down_jump, top_jump, ini, ha_h: miss_topology(x["main_core_fixed"], x["slice_group"], h, down_jump, top_jump, ini, ha_h)
-    return x.apply(func, args=(h, down_jump, top_jump, ini, ha_h), axis=1)
 
 
 def remote_hit_topology(main_core, helper_core, slice_group, C, h, H):
-    core0, ring0, _ = slice_msg_distance(main_core, slice_group)
+    core0, ring0 = slice_msg_distance(main_core, slice_group)
-    core1, ring1, _ = slice_msg_distance(helper_core, slice_group)
+    core1, ring1 = slice_msg_distance(helper_core, slice_group)
     return C + h*(core0+core1) + H*(ring0+ring1)
 
 def remote_hit_topology_df(x, C, h, H):
@@ -255,7 +223,7 @@ def remote_hit_topology_df(x, C, h, H):
 
 
 def do_predictions(df):
-    def plot_predicted_topo(col, row, x_ax, target, pred, df=df):
+    def plot_predicted_topo(col, row, x_ax, target, pred):
         title_letter = {
             "main_core_fixed": "A",
             "helper_core_fixed": "V",
@@ -270,54 +238,14 @@ def do_predictions(df):
 
 
     
-    values = []
+    df = df[(df["main_socket"] == 0) & (df["helper_socket"] == 0)]
-    main_socket, helper_socket = 0, 0
-    dfc = df[(df["main_socket"] == main_socket) & (df["helper_socket"] == helper_socket)]
-    cores = sorted(list(dfc["main_core_fixed"].unique()))
-    slices = sorted(list(dfc["slice_group"].unique()))
     res_miss = optimize.curve_fit(
-        miss_topology_df, dfc[["main_core_fixed", "slice_group"]], dfc["clflush_miss_n"]
+        miss_topology_df, df[["main_core_fixed", "slice_group"]], df["clflush_miss_n"]
     )
     print("Miss topology:")
     print(res_miss)
-    values.append(res_miss[0])
 
 
-    dfc["predicted_miss"] = miss_topology_df(dfc, *(res_miss[0]))
-    plot_predicted_topo("slice_group", None, "main_core_fixed", "clflush_miss_n", "predicted_miss", df=dfc)
-    plot_predicted_topo("main_core_fixed", None, "slice_group", "clflush_miss_n", "predicted_miss", df=dfc)
-
-    for slice_ in slices:
-        dfc = df[(df["slice_group"] == slice_) & (df["main_socket"] == main_socket) & (df["helper_socket"] == helper_socket)]
-        res_miss = optimize.curve_fit(
-            miss_topology_df, dfc[["main_core_fixed", "slice_group"]], dfc["clflush_miss_n"]
-        )
-        values.append(res_miss[0])
-
-        dfc[f"predicted_miss_{slice_}"] = miss_topology_df(dfc, *(res_miss[0]))
-        plot_predicted_topo("slice_group", None, "main_core_fixed", "clflush_miss_n", f"predicted_miss_{slice_}", df=dfc)
-
-
-    print(list(values[0]))
-    print()
-    for i in values[1:]:
-        print(list(i))
-
-    values = []
-    for core in cores:
-        dfc = df[(df["main_core_fixed"] == core) & (df["main_socket"] == main_socket) & (df["helper_socket"] == helper_socket)]
-        res_miss = optimize.curve_fit(
-            miss_topology_df, dfc[["main_core_fixed", "slice_group"]], dfc["clflush_miss_n"]
-        )
-        values.append(res_miss[0])
-
-        dfc[f"predicted_miss_core{core}"] = miss_topology_df(dfc, *(res_miss[0]))
-        plot_predicted_topo("main_core_fixed", None, "slice_group", "clflush_miss_n", f"predicted_miss_core{core}", df=dfc)
-
-    for i in values:
-        print(list(i))
-    return
-
     res_remote_hit = optimize.curve_fit(
         remote_hit_topology_df, df[["main_core_fixed", "helper_core_fixed", "slice_group"]], df["clflush_remote_hit"]
     )
@@ -325,24 +253,13 @@ def do_predictions(df):
     print(res_remote_hit)
 
 
+    df["predicted_miss"] = miss_topology_df(df, *(res_miss[0]))
+    plot_predicted_topo("slice_group", None, "main_core_fixed", "clflush_miss_n", "predicted_miss")
+    plot_predicted_topo("main_core_fixed", None, "slice_group", "clflush_miss_n", "predicted_miss")
 
-    df["diff_miss"] = df["clflush_miss_n"] - df["predicted_miss"]
+    df["predicted_remote_hit"] = remote_hit_topology_df(df, *(res_remote_hit[0]))
-    facet_grid(
+    plot_predicted_topo("slice_group", "helper_core_fixed", "main_core_fixed", "clflush_remote_hit", "predicted_remote_hit")
-        df, None, "main_core_fixed", "slice_group",
+    plot_predicted_topo("main_core_fixed", "helper_core_fixed", "slice_group", "clflush_remote_hit", "predicted_remote_hit")
-        title=f"predicted_miss_diff_facet_slice.png",
-        shown=["diff_miss"],
-        separate_hthreads=True
-    )
-    facet_grid(
-        df, None, "slice_group", "main_core_fixed",
-        title=f"predicted_miss_diff_facet_main.png",
-        shown=["diff_miss"],
-        separate_hthreads=True
-    )
-
-    # df["predicted_remote_hit"] = remote_hit_topology_df(df, *(res_remote_hit[0]))
-    # plot_predicted_topo("slice_group", "helper_core_fixed", "main_core_fixed", "clflush_remote_hit", "predicted_remote_hit")
-    # plot_predicted_topo("main_core_fixed", "helper_core_fixed", "slice_group", "clflush_remote_hit", "predicted_remote_hit")
     
     
 
@@ -398,34 +315,30 @@ def facet_grid(
                     **kwargs
                 )
         else:
-            grid.map(draw_fn, third, el, color=colors[i % len(colors)], marker='+')
+            grid.map(draw_fn, third, el, color=colors[i % len(colors)])
 
     if title is not None:
         plot(title, g=grid)
     return grid
 
 
-def all_facets(df, pre="", post="", no_helper=False, *args, **kwargs):
+def all_facets(df, pre="", post="", *args, **kwargs):
     """
     df : panda dataframe
     pre, post: strings to add before and after the filename
     """
 
-    helper = None if no_helper else "helper_core_fixed"
     facet_grid(
-        df, helper, "main_core_fixed", "slice_group",
+        df, "helper_core_fixed", "main_core_fixed", "slice_group",
-        title=f"{pre}facet_slice{post}.png", *args, **kwargs,
+        title=f"{pre}facet_slice{post}.png", *args, **kwargs
-        separate_hthreads=False
     )
     facet_grid(
-        df, helper, "slice_group", "main_core_fixed",
+        df, "helper_core_fixed", "slice_group", "main_core_fixed",
-        title=f"{pre}facet_main{post}.png", *args, **kwargs,
+        title=f"{pre}facet_main{post}.png", *args, **kwargs
-        separate_hthreads=False
     )
     facet_grid(
         df, "main_core_fixed", "slice_group", "helper_core_fixed",
-        title=f"{pre}facet_helper{post}.png", *args, **kwargs,
+        title=f"{pre}facet_helper{post}.png", *args, **kwargs
-        separate_hthreads=False
     )
 
 
@@ -456,7 +369,6 @@ def do_facet(main: int, helper: int, line: bool, metrics: str):
         post=f"_m{main}h{helper}",
         shown=shown,
         colors=colors,
-        no_helper=True,
         draw_fn=sns.lineplot if line else sns.scatterplot
     )
 
@@ -464,28 +376,19 @@ def do_facet(main: int, helper: int, line: bool, metrics: str):
 if args.rslice:
     rslice()
 
-do_predictions(stats)
+# do_predictions(stats)
-#all_facets(stats, shown=["clflush_remote_hit"], colors=["r"], pre="hit")
+# all_facets(stats, shown=["clflush_remote_hit"], colors=["r"])
-#all_facets(stats, shown=["clflush_miss_n"], colors=["b"], pre="miss")
-
-#df=stats
-#for m, h, s in itertools.product((0, 1), (0, 1), df["slice_group"].unique()):
-#    dfc = df[(df["main_socket"] == m) & (df["main_core_fixed"]%8é == s) & (df["helper_socket"] == h)]
-#
-#    grid = sns.FacetGrid(dfc, row=None, col=None)
-#    grid.map(sns.scatterplot, "slice_group", "clflush_miss_n", marker="+")
-#
-#    plot(f"miss_m{m}h{h}m{s}", g=grid)
 
 
-#with Pool(8) as pool:
+
-#    pool.starmap(
+with Pool(8) as pool:
-#        do_facet,
+    pool.starmap(
-#        itertools.product(
+        do_facet,
-#            stats["main_socket"].unique(),
+        itertools.product(
-#            stats["helper_socket"].unique(),
+            stats["main_socket"].unique(),
-#            (False, ),
+            stats["helper_socket"].unique(),
-#            ("hit", "miss")
+            (True, False),
-#        )
+            ("hit", "miss")
-#    )
+        )
+    )
 

cache_utils/remap_cores.py

@@ -1,25 +0,0 @@
-import sys
-
-if len(sys.argv) != 3:
-    print(f"Usage: {sys.argv[0]} <input.csv> <mapping>")
-    sys.exit(1)
-
-input_file = sys.argv[1]
-mapping_file = sys.argv[2]
-
-mapping = []
-with open(mapping_file, "r") as f:
-    for i in f.read().split("\n"):
-        if i != "":
-            mapping.append(int(i))
-
-
-with open(input_file, "r") as f:
-    for line in f.read().split("\n"):
-        if line == "" or "core" in line:
-            print(line)
-            continue
-
-        sock, core, ht = map(int, line.split(","))
-        core = mapping[core]
-        print(f"{sock},{core},{ht}")