reproduce_paper_results.py

# Import python modules 
import os
import sys
import math
import copy
import time
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.markers import MarkerStyle
from matplotlib.lines import Line2D

# Add the subdirectory to the sys.path
sys.path.append(os.path.join(os.path.dirname(__file__), 'rapid_chiplet'))
# Import RapidChiplet design visualizer
import rapid_chiplet.design_visualizer as dv

# Import custom modules
import config as cfg
import topology_analyzer as ta
import experiment_setup as es
import io_helpers as ioh
import aux_helpers as auxh
import design_generator as dgen
import placement as plac
import topology as topo
import run_experiments as re
import trace_based_evaluation as tbe

# Create the plot showing the maximum data rate as a function of the link length
def fig_rate_vs_length():
	print("Creating the rate-vs-length plot...")
	start_time = time.time()
	# For this plot we use the same chiplet size and spacing for all packaging technologies organic and glass
	chiplet_side = math.sqrt(74)			# mm (use 74mm2 as AMD EPYC and RYZEN)
	chiplet_spacing = 0.15 					# mm (0.1mm as in #349 for APX (organic)
	padding_straight = 0.6298906841861016	# mm (assuming 74mm2 chiplet, 50% power-bumps, 4 links on edges)
	padding_diagonal = 1.5206906325745548	# mm (assuming 74mm2 chiplet, 50% power-bumps, 4 links in corners)
	# Configure plot
	colors = {"organic":"#BBBB77","glass":"#6666AA","silicon":"#AA6666"}
	linestyles = {"glass":(0,(1.5,1)),"organic":(0,(3,1)),"silicon":(0,(6,1))}
	interposers = ["glass","organic","silicon"]
	# Compute straight and diagonal lengths
	len_straight = {l : 2 * padding_straight + (l+1) * chiplet_spacing + l * chiplet_side for l in range(1,4)}
	len_diag = {l : math.sqrt(2 * (2 * padding_diagonal + (l+1) * chiplet_spacing + l * chiplet_side)**2) for l in range(1,4)}
	# Compute rate-vs-length data
	lengths = [i/10.0 for i in range(701)]
	rates = {interp : [auxh.get_max_rate(l, interp) * 1e-9 for l in lengths] for interp in interposers}	# Gbps
	# Create figure
	fig, ax = plt.subplots(1,1, figsize = (4,2))
	fig.subplots_adjust(left=0.11, right=0.975, top=0.925, bottom=0.2)
	# Plot rate-vs-length data
	for interp in interposers:
		lwd = 1 if interp == "silicon" else 2
		ax.plot(lengths, rates[interp], color = colors[interp], linestyle = linestyles[interp], linewidth = lwd, zorder = 2, label = interp.capitalize())
	# Plot straight and diagonal lengths
	for l in range(1,3):
		# Plot vertical intervals for 1, 2 and 3 hops
		ax.vlines(len_straight[l], 0, 80, color = "black", linestyle = ":", linewidth = 1, zorder = 4)
		ax.text(len_straight[l]+0.3, 1, "straight", fontsize = 4.5, ha = "left", va = "bottom", rotation = 90, fontweight = "bold")
		ax.vlines(len_diag[l], 0, 80, color = "black", linestyle = "--", linewidth = 1, zorder = 4)
		ax.fill_between([len_straight[l], len_diag[l]], 0, 80, color = "black", alpha = 0.1, zorder = 0)
		ax.text(len_diag[l]-0.3, 1, "diagonal", fontsize = 4.5, ha = "right", va = "bottom", rotation = 90, fontweight = "bold")
		ax.text((len_straight[l] + len_diag[l])/2, 1, "link-range %d" % l, fontsize = 5.7, ha = "center", va = "bottom", fontweight = "bold", rotation = 90)
		# ax.annotate('', xy=(len_straight[l]-0.75, 22), xytext=(len_diag[l]+0.75, 22),arrowprops=dict(arrowstyle='<->', color='black', lw=1.0, mutation_scale=5), zorder = 4)
		# Plot horizontal intervals for corresponding data rates
		for interp in [x for x in interposers if x != "silicon"]:
			upper_rate = auxh.get_max_rate(len_straight[l], interp) * 1e-9	# Gbps
			lower_rate = auxh.get_max_rate(len_diag[l], interp) * 1e-9		# Gbps
			l_perc = 100 * lower_rate / max(rates[interp])
			u_perc = 100 * upper_rate / max(rates[interp])
			txt = ("link-range %d:\n%d-%d%%" % (l, int(l_perc), int(u_perc))) if l_perc != u_perc else ("rate: %d%%" % int(l_perc))
			side1 = 0 if interp == "organic" else 70
			if interp == "organic":
				xvals = [x / 10 for x in range(int(10 * len_diag[l]) + 1)]
				f_upper = lambda x : upper_rate if x < len_straight[l] else auxh.get_max_rate(x, interp) * 1e-9
				lower_vals = [lower_rate for x in xvals]
				upper_vals = [f_upper(x) for x in xvals]
				ax.fill_between(xvals, lower_vals, upper_vals, color = colors[interp], alpha = 0.5, zorder = 1)
				ax.text(5.25, (lower_rate + upper_rate)/2, txt, fontsize = 5, ha = "center", va = "center", fontweight = "bold", zorder = 10, linespacing = 1.0)
			if interp == "glass":
				xvals = [x / 10 for x in range(int(10 * len_straight[l]), 701)]
				f_lower = lambda x : lower_rate if x > len_diag[l] else auxh.get_max_rate(x, interp) * 1e-9
				lower_vals = [f_lower(x) for x in xvals]
				upper_vals = [upper_rate for x in xvals]
				ax.fill_between(xvals, lower_vals, upper_vals, color = colors[interp], alpha = 0.5, zorder = 1)
				ax.text(64.75, (lower_rate + upper_rate)/2, txt, fontsize = 5, ha = "center", va = "center", fontweight = "bold", zorder = 10, linespacing = 1.0)
	# Configure plot
	ax.legend(loc = "lower center", fontsize = 8, bbox_to_anchor=(0.5,0.94), frameon = False, ncol = 3, columnspacing = 1.0, handletextpad = 0.1)
	ax.set_xlabel("Link length [mm]", fontsize = 8)
	ax.set_ylabel("Max. data rate [Gbit/s]", fontsize = 8)
	ax.set_yticks([10 * i for i in range(9)])
	ax.set_yticklabels(ax.get_yticklabels(), fontsize = 8)
	ax.set_xlim([0,70])
	ax.set_ylim([0,80])
	# Store plots
	plt.savefig("plots/rate_vs_length.pdf")
	plt.close()
	# Print timing information
	print("   |-> done in %.2f seconds." % (time.time() - start_time))

# Visualize the topologies used in the exploration or evaluation 
# Note: The visualizations will be saved in "./rapid_chiplet/visualizations/" and not in "./plots/"
def visualize_topologies(configurations, suffix = ""):
	topo_names = [x[0] for x in configurations]
	print("Visualizing the topologies %s..." % (", ".join(topo_names)))
	start_time = time.time()
	# Read the parameters 
	# For the visualization, we use the parameters from organic - there would be no difference for glass as the
	# only parameter affecting the visualization is the chiplet spacing, which is overwrite for the visualization
	# We visualize the homogeneous case
	base_params = es.parameter_map["organic"]
	# Iterate over configurations
	for (name, placement, topology, n_chiplets, rows, cols, radius, af, lw) in configurations:
		# Iterate over architectures
		for arch in ["homogeneous", "heterogeneous"]:
			# Set parameters of this configuration
			params = copy.deepcopy(base_params)
			params["design_name"] = name
			params["technology"] = name
			params["architecture"] = arch
			params["traffic_pattern"] = "none"
			params["n_chiplets"] = n_chiplets
			params["rows"] = rows
			params["cols"] = cols
			params["r"] = radius
			# We set the chiplet spacing higher than in the experiments to make the visualization look nicer 
			params["chiplet_spacing"] = 1.0
			# Create the design
			design = dgen.generate_design(params, placement, topology)
			# Visualize the design
			os.chdir("./rapid_chiplet")
			img_name = name + "_" + arch + suffix
			dv.visualize_design(img_name, design, show_id = False, arc_factor = af, line_width = lw)
			os.chdir("../")
	# Print timing information
	print("   |-> done in %.2f seconds." % (time.time() - start_time))


def print_stats_for_exploration(metric):
	print(f"Printing the {metric} statistics for the exploration...")
	start_time = time.time()
	print("=" * 100)
	print("Substrate\tChiplet-Area\tTopology\t\tChiplet-Count\t%s Overhead" % metric.capitalize())
	print("=" * 100)
	# Iterate through substrates
	for substrate in ["organic","glass"]:
		# Iterate through chiplet areas
		for chiplet_area in [37,74,148]:
			experiment_name = "exploration_%s_%d" % (substrate, chiplet_area)
			# Check if the results are available
			if os.path.isfile("results/results_%s.json" % experiment_name):
				# Read the results
				results = ioh.read_file("results/results_%s.json" % experiment_name)
				# Iterate through topologies and chiplet counts
				for topology_name in results.keys():
					chiplet_counts_str_sorted = sorted(results[topology_name].keys(), key = lambda x : int(x))
					values_accross_chiplet_counts = []
					for n_chiplets_str in chiplet_counts_str_sorted:
						n_chiplets = int(n_chiplets_str)
						# Extract metric of this topology and chiplet count
						value = results[topology_name][n_chiplets_str][metric]
						# Extract baseline area
						if "Mesh" in results.keys():
							# There is a mesh topology with the same number of chiplets
							if n_chiplets_str in results["Mesh"].keys():
								bl_value = results["Mesh"][n_chiplets_str][metric]
							# Interpolate the baseline value
							elif min([int(x) for x in results["Mesh"].keys()]) < n_chiplets < max([int(x) for x in results["Mesh"].keys()]):
								lower_cnt = max([int(x) for x in results["Mesh"].keys() if int(x) <= n_chiplets])
								upper_cnt = min([int(x) for x in results["Mesh"].keys() if int(x) >= n_chiplets])
								lower_value = results["Mesh"][str(lower_cnt)][metric]
								upper_value = results["Mesh"][str(upper_cnt)][metric]
								bl_value = lower_value + (n_chiplets - lower_cnt) * (upper_value - lower_value) / (upper_cnt - lower_cnt)
							# Extrapolate to lower values
							elif n_chiplets < min([int(x) for x in results["Mesh"].keys()]):
								keys_sorted = sorted([int(x) for x in results["Mesh"].keys()])
								lower_cnt = keys_sorted[0]
								upper_cnt = keys_sorted[1]
								lower_value = results["Mesh"][str(lower_cnt)][metric]
								upper_value = results["Mesh"][str(upper_cnt)][metric]
								bl_value = lower_value + (n_chiplets - lower_cnt) * (upper_value - lower_value) / (upper_cnt - lower_cnt)
							# Extrapolate to higher values
							elif n_chiplets > max([int(x) for x in results["Mesh"].keys()]):
								keys_sorted = sorted([int(x) for x in results["Mesh"].keys()])
								lower_cnt = keys_sorted[-2]
								upper_cnt = keys_sorted[-1]
								lower_value = results["Mesh"][str(lower_cnt)][metric]
								upper_value = results["Mesh"][str(upper_cnt)][metric]
								bl_value = lower_value + (n_chiplets - lower_cnt) * (upper_value - lower_value) / (upper_cnt - lower_cnt)
							else:
								raise ValueError(f"Unable to interpolate of extrapolate the baseline {metric} value for {topology_name} with {n_chiplets} chiplets.")
							overhead = (value * 100 / bl_value) - 100
							overhead = abs(overhead) if abs(overhead) < 0.0001 else overhead	# Avoids -0.00%
							values_accross_chiplet_counts.append(overhead)
						else:
							raise ValueError(f"Results for Mesh are not available -> Unable to compute relative {metric}.")					
					mean_value = np.mean(values_accross_chiplet_counts)	
					std_value = np.std(values_accross_chiplet_counts)
					extra_tab = "\t" if len(topology_name) < 8 else ""
					print("%s\t\t%d\t\t%s%s\t\t%.2f%% (%.2f%%)" % (substrate, chiplet_area, topology_name, extra_tab, mean_value, std_value))

			else:
				raise ValueError("Results for %s are not available." % experiment_name)
	# Print timing information
	print("=" * 100)
	print("   |-> done in %.2f seconds." % (time.time() - start_time))

def fig_exploration(experiment_name):
	topo_order = [
		"Mesh",
		"FoldedTorus",
		"HexaMesh",
		"FoldedHexaTorus",
		"OctaMesh",
		"FoldedOctaTorus",
	]
	print("Creating the exploration plot for %s..." % experiment_name)
	start_time = time.time()
	data = ioh.read_file("results/results_%s.json" % experiment_name)
	# Prepare figure
	(fig, ax) = plt.subplots(1, 2, figsize = (6,3))
	fig.subplots_adjust(left=0.1, right=0.975, top=0.9, bottom=0.15, wspace = 0.3)
	# Iterate through metrics (= subplots)
	for (i, metric) in enumerate(["abs_throughput","latency"]):
		ymax = 0
		topos = sorted(data.keys(), key = lambda x : topo_order.index(x) if x in topo_order else -1)
		# Iterate through topologies (= lines)
		for (j, name) in enumerate(topos):
			# Extract data
			chiplet_counts_str_sorted = sorted(data[name].keys(), key = lambda x : int(x))
			xvals = [int(x) for x in chiplet_counts_str_sorted]
			yvals = [data[name][x][metric] * (1e-12 if metric == "abs_throughput" else 1) for x in chiplet_counts_str_sorted]	# Tbit/s or ns
			ymax = max(ymax, max(yvals))
			(mar, col, lin, smf) = cfg.marker_color_line_map[name]
			mfc = col if smf else 'none'
			# Plot data
			ax[i].plot(xvals, yvals, label = name, marker = mar, color = col, linestyle = lin, markerfacecolor = mfc, markersize = 4, linewidth = 1.5)
		# Configure plots
		ax[i].set_xlabel("Number of Chiplets", fontsize = 11)
		ax[i].set_xlim(0,300)
		ax[i].set_xticks([0,100,200,300])
		ylim = int((int(ymax / 50) + 1) * 50)
		ax[i].set_ylim(bottom = 0, top = ylim)
		ax[i].set_yticks(list(range(0, ylim+1, 50 if ylim > 150 else 25)))
		ax[i].grid()	
	# Configure plots
	ax[0].set_ylabel("Throughput per chiplet [Tbit/s]", fontsize = 11)
	ax[1].set_ylabel("Average packet latency [ns]", fontsize = 11)
	ax[0].legend(loc = "upper left", fontsize = 9, frameon = False, bbox_to_anchor=(-0.28,1.15), ncol = 6, columnspacing = 0.75, handletextpad = 0.1, handlelength = 1.25)
	# Save plots	
	plt.savefig("plots/%s.pdf" % experiment_name)
	plt.close()
	# Print timing information
	print("   |-> done in %.2f seconds." % (time.time() - start_time))
	

# Visualize the topologies used in the exploration
def fig_evaluation():
	print("Creating the evaluation plot...")
	start_time = time.time()
	topo_order = [
		"Mesh",
		"Torus",
		"FoldedTorus",
		"DoubleButterfly",
		"ButterDonut",
		"SIDMesh",
		"KiteSmall",
		"KiteMedium",
		"KiteLarge", 
		"HexaMesh",
		"FoldedHexaTorus",
		"ClusCrossV1",
		"ClusCrossV2",
		"Hypercube",
		"FlattenedButterfly",
	]
	# Configure required data
	architectures = ["homogeneous","heterogeneous"]
	substrates = ["organic","glass"]
	paths_to_files = {(substr, arch) : "results/results_evaluation_%s_%s.json" % (arch, substr) for substr in substrates for arch in architectures}
	# Check if all four data files exist
	missing_data_flag = False
	for path in paths_to_files.values():	
		if not os.path.isfile(path):
			missing_data_flag = True
	# If data is missing, run the evaluation (taking multiple hours)
	if missing_data_flag:	
		raise ValueError("Evaluation data is missing. Please run the evaluation first.")
	# Read the results
	results = {key : ioh.read_file(path) for key, path in paths_to_files.items()}
	# Sort entries by design size
	for key in results.keys():
		for topo in results[key].keys():
			results[key][topo] = {int(k) : results[key][topo][str(k)] for k in sorted([int(x) for x in results[key][topo].keys()])}
	# Remove entries with zero-throughput (link length exceeded)
	for key in results.keys():
		for topo in results[key].keys():
			results[key][topo] = {k : v for k,v in results[key][topo].items() if v["abs_throughput"] > 0}
	# Compute the relative area overhead (induced by PHYs) and the relative power overhead (induced by PHYs)
	for key in results.keys():		
		substr = key[0]
		params = es.parameter_map[substr]
		for topo in results[key].keys():
			for n_chiplets in results[key][topo].keys():	
				data = results[key][topo][n_chiplets]
				total_area = data["area"]
				total_power = data["power"]
				phy_area = total_area - int(n_chiplets) * params["base_area"]
				phy_power = total_power - int(n_chiplets) * params["base_power"]
				data["rel_area"] = (phy_area * 100 / total_area)
				data["rel_power"] = (phy_power * 100 / total_power)
	# Create the plots
	(fig, ax) = plt.subplots(4, 4, figsize = (12,16))
	fig.subplots_adjust(left=0.06, right=0.985, top=0.92, bottom=0.04, wspace = 0.1, hspace = 0.075)
	ylims = {"abs_throughput" : [1, 1000], "latency" : [0, 100], "rel_area" : [0, 20], "rel_power" : [0.01, 100]}
	yticsk = {"abs_throughput" : [1,10,100,1000], "latency" : [0,20,40,60,80,100], "rel_area" : [0,5,10,15,20], "rel_power" : [0.01,0.1,1,10,100]}
	# Iterate through columns (interposers and experiment types)
	for (c, (interp, exp_type)) in enumerate(results.keys()):
		data = results[(interp, exp_type)]
		# Iterate through rows (metrics)
		for (r, metric) in enumerate(["abs_throughput","latency","rel_area","rel_power"]):
			# Read and order topologies
			topos = sorted(list(data.keys()), key = lambda x : topo_order.index(x) if x in topo_order else -1)
			# Iterate through data series (topologies)
			for (i, topo) in enumerate(topos):
				# Extract data
				xvals = [int(x) for x in data[topo].keys()]
				yvals = [data[topo][x][metric] * (1e-12 if metric == "abs_throughput" else 1) for x in data[topo].keys()]	# Tbit/s or ns
				(mar, col, lin, smf) = cfg.marker_color_line_map[topo]
				mfc = col if smf else 'none'
				# Plot data
				ax[r][c].plot(xvals, yvals, label = topo, marker = mar, color = col, linestyle = lin, markerfacecolor = mfc, markersize = 4, linewidth = 1.5, zorder = 3)
				# Plot additional vertical line for throughput that jumps to zero
				if metric == "abs_throughput" and max(xvals) < 200:
					ax[r][c].vlines(xvals[-1], yvals[-1], 0, color = col, linestyle = lin, linewidth = 1.5, zorder = 3)
			# Configure subplot
			ax[r][c].grid(zorder = 0, which = "both")
			ax[r][c].set_xlim(0,300)
			ax[r][c].set_xticks([0,100,200,300])
			ax[r][c].set_xticklabels([])	
			ax[r][c].set_yscale("log" if metric in ["abs_throughput","rel_power"] else "linear")
			ax[r][c].set_ylim(ylims[metric])
			ax[r][c].set_yticks(yticsk[metric])
			ax[r][c].set_yticklabels([])	
	# Add legend to top
	ax[0][0].legend(loc = "lower left", fontsize = 11, frameon = False, bbox_to_anchor=(0.0,1.06), ncol = 6, columnspacing = 2, handletextpad = 0.5, handlelength = 2.5)
	# Add x-labels to the bottom row
	for c in range(4):
		ax[3][c].set_xticklabels([0,100,200,300], fontsize = 11)
		ax[3][c].set_xlabel("Number of Chiplets", fontsize = 11)
	# Add y-labels to the left column
	ax[0][0].set_ylabel("Throughput per chiplet [Tbit/s]", fontsize = 11)
	ax[1][0].set_ylabel("Average packet latency [ns]", fontsize = 11)
	ax[2][0].set_ylabel("Area occupied by PHYs [%]", fontsize = 11)
	ax[3][0].set_ylabel("Power consumed by PHYs [%]", fontsize = 11)
	for (r, metric) in enumerate(["abs_throughput","latency","rel_area","rel_power"]):
		ax[r][0].set_yticklabels(yticsk[metric], fontsize = 11)
	# Save plots	
	plt.savefig("plots/evaluation.pdf")
	plt.close()
	# Print timing information
	print("   |-> done in %.2f seconds." % (time.time() - start_time))

def fig_extended_evaluation():
	print("Creating the extended evaluation plot...")
	start_time = time.time()
	topo_order = [
		"Mesh",
		"Torus",
		"FoldedTorus",
		"DoubleButterfly",
		"ButterDonut",
		"SIDMesh",
		"KiteSmall",
		"KiteMedium",
		"KiteLarge", 
		"HexaMesh",
		"FoldedHexaTorus",
		"ClusCrossV1",
		"ClusCrossV2",
		"Hypercube",
		"FlattenedButterfly",
	]
	# Configure required data
	substrates = ["organic","glass"]
	traffic_patterns = ["randperm","tornado","neighbor"]
	paths_to_files = {(substr, traffic) : "results/results_extended_evaluation_%s_%s.json" % (substr, traffic) for substr in substrates for traffic in traffic_patterns}
	# Check if all four data files exist
	missing_data_flag = False
	for path in paths_to_files.values():	
		if not os.path.isfile(path):
			missing_data_flag = True
	# If data is missing, run the evaluation (taking multiple hours)
	if missing_data_flag:	
		raise ValueError("Extended evaluation data is missing. Please run the extended evaluation first.")
	# Read the results
	results = {key : ioh.read_file(path) for key, path in paths_to_files.items()}
	# Sort entries by design size
	for key in results.keys():
		for topo in results[key].keys():
			results[key][topo] = {int(k) : results[key][topo][str(k)] for k in sorted([int(x) for x in results[key][topo].keys()])}
	# Remove entries with zero-throughput (link length exceeded)
	for key in results.keys():
		for topo in results[key].keys():
			results[key][topo] = {k : v for k,v in results[key][topo].items() if v["abs_throughput"] > 0}
	# Create the plots
	(fig, ax) = plt.subplots(6, 2, figsize = (6,30))
	fig.subplots_adjust(left=0.12, right=0.978, top=0.9, bottom=0.03, wspace = 0.3, hspace = 0.075)
	ylims = {"abs_throughput" : [1, 1000], "latency" : [0, 100]}
	yticsk = {"abs_throughput" : [1,10,100,1000], "latency" : [0,20,40,60,80,100,120,140]} 
	# Iterate through rows (interposers and traffic)
	for (r, (interp, traffic)) in enumerate(results.keys()):
		data = results[(interp, traffic)]
		# Iterate through columns(metrics)
		for (c, metric) in enumerate(["abs_throughput","latency"]):
			# Read and order topologies
			topos = sorted(list(data.keys()), key = lambda x : topo_order.index(x) if x in topo_order else -1)
			# Iterate through data series (topologies)
			for (i, topo) in enumerate(topos):
				# Extract data
				xvals = [int(x) for x in data[topo].keys()]
				yvals = [data[topo][x][metric] * (1e-12 if metric == "abs_throughput" else 1) for x in data[topo].keys()]	# Tbit/s or ns
				(mar, col, lin, smf) = cfg.marker_color_line_map[topo]
				mfc = col if smf else 'none'
				# Plot data
				ax[r][c].plot(xvals, yvals, label = topo, marker = mar, color = col, linestyle = lin, markerfacecolor = mfc, markersize = 4, linewidth = 1.5, zorder = 3)
				# Plot additional vertical line for throughput that jumps to zero
				if metric == "abs_throughput" and max(xvals) < 200:
					ax[r][c].vlines(xvals[-1], yvals[-1], 0, color = col, linestyle = lin, linewidth = 1.5, zorder = 3)
			# Configure subplot
			ax[r][c].grid(zorder = 0, which = "both")
			ax[r][c].set_xlim(0,300)
			ax[r][c].set_xticks([0,100,200,300])
			ax[r][c].set_xticklabels([])	
			ax[r][c].set_yscale("log" if metric == "abs_throughput" else "linear")
			ax[r][c].set_ylim(ylims[metric])
			ax[r][c].set_yticks(yticsk[metric])
			# Title - maybe remove for the paper
			ax[r][c].set_title(f"{interp.capitalize()} - {traffic.capitalize()}", fontsize = 11)
	# Add legend to top
	ax[0][0].legend(loc = "lower left", fontsize = 11, frameon = False, bbox_to_anchor=(0.0,1.05), ncol = 2, columnspacing = 2, handletextpad = 0.5, handlelength = 2.5)
	# Add x-labels to the bottom row
	for c in range(2):
		ax[5][c].set_xticklabels([0,100,200,300], fontsize = 11)
		ax[5][c].set_xlabel("Number of Chiplets", fontsize = 11)
	# Add y-labels (all)
	for r in range(6):
		ax[r][0].set_ylabel("Throughput per chiplet [Tbit/s]", fontsize = 11)
		ax[r][1].set_ylabel("Average packet latency [ns]", fontsize = 11)
	# Save plots	
	plt.savefig("plots/extended_evaluation.pdf")
	plt.close()
	# Print timing information
	print("   |-> done in %.2f seconds." % (time.time() - start_time))


def fig_trace_evaluation(traces):
	# Suppress warnings about the tick labels
	import warnings
	with warnings.catch_warnings():
		warnings.filterwarnings("ignore", category=UserWarning, message=".*set_ticklabels.*")
		print("Creating the trace evaluation plot...")
		start_time = time.time()
		topo_order = [
			"Mesh",
			"Torus",
			"FoldedTorus",
			"DoubleButterfly",
			"ButterDonut",
			"SIDMesh",
			"KiteSmall",
			"KiteMedium",
			"KiteLarge", 
			"HexaMesh",
			"FoldedHexaTorus",
			"HoneycombMesh",
			"ClusCrossV1",
			"ClusCrossV2",
			"Hypercube",
			"FlattenedButterfly",
		]
		# Configure required data
		regions = list(range(5))
		paths_to_files = {(trace, region) : "results/results_trace_evaluation_%s_%d.json" % (trace, region) for trace in traces for region in regions}
		# Check if all four data files exist
		missing_data_flag = False
		for path in paths_to_files.values():	
			if not os.path.isfile(path):
				missing_data_flag = True
		# If data is missing, run the evaluation (taking multiple hours)
		if missing_data_flag:	
			raise ValueError("Trace evaluation data is missing. Please run the trace evaluation first.")
		# Read the results
		results = {key : ioh.read_file(path) for key, path in paths_to_files.items()}
		# Create the plots
		(fig, ax) = plt.subplots(len(traces), len(regions), figsize = (2.5 * len(regions), 2.5 * len(traces) + 1))
		fig.subplots_adjust(left=0.05, right=0.985, top=0.85, bottom=0.075, wspace = 0.05, hspace = 0.05)
		# Iterate through columns (traces)
		for (r, trace) in enumerate(traces):
			# Iterate through regions (shades of the point)
			for (c, region) in enumerate(regions):
				data = results[(trace, region)]
				# Read and order topologies
				topos = sorted(list(data.keys()), key = lambda x : topo_order.index(x) if x in topo_order else 1000)
				# Iterate through topologies (colors and markers)
				for (i, topo) in enumerate(sorted(topos, key = lambda x : topo_order.index(x) if x in topo_order else -1)):
					n_chiplets_str = list(data[topo].keys())[0]
					tp = data[topo][n_chiplets_str]["abs_throughput"] * 1e-12 	# Tbis/s
					lat = data[topo][n_chiplets_str]["latency"] 				# ns = cycles
					(mar, col, lin, smf) = cfg.marker_color_line_map[topo]
					lab = topo if region == 0 else ""
					(mfc, mfs) = {"-" : (col,"full"), "--" : (col,"right"), ":" : ("none","full")}[lin]
					marker = MarkerStyle(mar, fillstyle=mfs)
					ax[r][c].plot(lat, tp, label = lab, marker = marker, color = col, markerfacecolor = mfc, markersize = 8, linestyle = "none")
				# Configure subplot
				ax[r][c].grid(zorder = 0, which = "both")
				if r == 0:
					ax[r][c].set_title("Region %d" % (region))
				# X-axis
				ax[r][c].set_xlim(40,2000)	
				ax[r][c].set_xscale("log", base=10)
				if r == len(traces)-1:
					ax[r][c].set_xlabel("Average packet latency [ns]")
				else:
					ax[r][c].set_xticklabels(["" for x in ax[r][c].get_xticks()])
				# Y-axis
				ax[r][c].set_ylim(0,30 if "black" in trace else 60)
				if c == 0:
					ax[r][c].set_ylabel("Throughput per chiplet [Tbit/s]")
				else:
					ax[r][c].set_yticklabels(["" for x in ax[r][c].get_yticks()])
				# Prepare legend with fill colors
				if r==0 and c==0:
					legend_items = []
					for topo in topos:
						(mar, col, lin, smf) = cfg.marker_color_line_map[topo]
						(mfc, mfs) = {"-" : (col,"full"), "--" : (col,"right"), ":" : ("none","full")}[lin]
						legend_items.append(Line2D([], [], marker=mar, linestyle='None', markerfacecolor=mfc, markeredgecolor=col, markeredgewidth=1, fillstyle=mfs, label=topo))
			# Title - maybe remove for the paper
			fig.text(0.994,0.66,"Blackscholes", rotation = 90, ha = "center", va = "center", fontsize = 12, fontweight = "bold")
			fig.text(0.994,0.26,"Fluidanimate", rotation = 90, ha = "center", va = "center", fontsize = 12, fontweight = "bold")
		# Add legend to top
		ax[0][0].legend(handles=legend_items, loc = "lower left", fontsize = 11, frameon = False, bbox_to_anchor=(-0.1,1.06), ncol = 6, columnspacing = 2, handletextpad = 0.5, handlelength = 2.5)
		# Save plots	
		plt.savefig("plots/trace_evaluation.pdf")
		plt.close()

if __name__ == "__main__":
	# ================================ Figures and Visualizations ================================
	# Create Figure 2: Link length vs data rate
	fig_rate_vs_length()
	# Visualize the topologies used in the exploration (Figure 3) and evaluation (Figure 5)
	for chapter in ["exploration","evaluation"]:
		configurations = es.topology_configuration_map[chapter]
		visualize_topologies(configurations, suffix = "_"+ chapter)
	# ================================ Exploration ================================
	# Make sure all exploration results are available
	architecture = "homogeneous"			# Use homogeneous parameters for the exploration
	topo_configs = es.topology_configuration_map["exploration"]
	for substrate in ["organic","glass"]:	# Run for both substrates but only show organic in the paper
		base_params = es.parameter_map[substrate]
		base_params["traffic_pattern"] = "C2C"	# Random uniform Core-to-Core traffic
		for chiplet_area in [37,74,148]:	# 0.5x 1.0x 2.0x the area of a CCD in #92
			experiment_name = "exploration_%s_%d" % (substrate, chiplet_area)
			# Only run the experiment if the results are not already available
			if not os.path.isfile("results/results_%s.json" % experiment_name):
				re.run_experiment(topo_configs, base_params, es.size_mapper, chiplet_area, architecture, experiment_name)
	# Report the area statistics for the exploration (used  in text of the paper)
	print_stats_for_exploration("area")
	print_stats_for_exploration("power")
	# Create the exploration plot (Figure 4)
	for substrate in ["organic","glass"]:
		for chiplet_area in [37,74,148]:
			experiment_name = "exploration_%s_%d" % (substrate, chiplet_area)
			fig_exploration(experiment_name)
	# ================================ Evaluation: Random Uniform  Traffic ================================
	# Make sure all evaluation results are available
	topo_configs = es.topology_configuration_map["evaluation"]
	chiplet_area = 74
	for architecture in ["homogeneous","heterogeneous"]:
		for substrate in ["organic","glass"]:
			base_params = es.parameter_map[substrate]
			base_params["traffic_pattern"] = ("C2C"	if architecture == "homogeneous" else "C2C+C2M") # Random uniform traffic
			experiment_name = "evaluation_%s_%s" % (architecture, substrate)
			# Only run the experiment if the results are not already available
			if not os.path.isfile("results/results_%s.json" % experiment_name):
				re.run_experiment(topo_configs, base_params, es.size_mapper, chiplet_area, architecture, experiment_name)
	# Create the evaluation plot (Figure 7)
	fig_evaluation()
	# ================================ Extended Evaluation: Other traffic patterns ================================
	# Make sure all evaluation results are available
	topo_configs = es.topology_configuration_map["evaluation"]
	chiplet_area = 74
	architecture = "homogeneous"
	for substrate in ["organic","glass"]:
		for traffic_pattern in ["randperm","tornado","neighbor"]:
			base_params = es.parameter_map[substrate]
			base_params["traffic_pattern"] = traffic_pattern
			experiment_name = "extended_evaluation_%s_%s" % (substrate, traffic_pattern)
			# Only run the experiment if the results are not already available
			if not os.path.isfile("results/results_%s.json" % experiment_name):
				re.run_experiment(topo_configs, base_params, es.size_mapper, chiplet_area, architecture, experiment_name)
	# Create the extended evaluation plot (Figure 8)
	fig_extended_evaluation()
	# ================================ Trace-Based Evaluation ================================
	traces = [	"blackscholes_64c_simsmall",
				"fluidanimate_64c_simsmall",
			 ]
	topo_configs = es.topology_configuration_map["evaluation"]
	# Make sure all trace-based evaluation results are available	
	traces_to_run = []
	for trace in traces:	
		for region in range(5):
			if not os.path.isfile("results/results_trace_evaluation_%s_%d.json" % (trace, region)):
				if trace not in traces_to_run:
					traces_to_run.append(trace)
	if len(traces_to_run) > 0:
		tbe.run_trace_based_evaluation(topo_configs, traces_to_run)
	# Create the trace evaluation plot (Figure 10)
	fig_trace_evaluation(traces)
	sys.exit(0)