def test2_pReader(self):
print("test2 pReader r")
reader = PlainReader("{}/trace.txt".format(DAT_FOLDER))
cH = CHeatmap()
bpv = cH.get_breakpoints(reader, 'v', time_interval=1000)
self.assertEqual(bpv[10], 10000)
cH.heatmap(reader, 'v', "hit_ratio_start_time_end_time",
time_interval=1000, num_of_threads=os.cpu_count(), cache_size=2000,
figname="pReader_hr_st_et_LRU.png")
cH.heatmap(reader, 'v', "rd_distribution",
time_interval=1000, num_of_threads=os.cpu_count(),
figname="pReader_rd_dist.png")
cH.heatmap(reader, 'v', "future_rd_distribution",
time_interval=1000, num_of_threads=os.cpu_count(),
figname="pReader_frd_dist.png")
cH.heatmap(reader, 'v', "hit_ratio_start_time_end_time",
time_interval=10000, algorithm="FIFO",
num_of_threads=os.cpu_count(), cache_size=2000,
figname="pReader_hr_st_et_FIFO.png")
cH.diff_heatmap(reader, 'v', "hit_ratio_start_time_end_time",
time_interval=10000, cache_size=200,
algorithm1="LFU", algorithm2="Optimal",
cache_params2=None, num_of_threads=os.cpu_count(),
figname="pReader_diff_hr_st_et.png")
def test1_vReader(self):
print("test1 vReader")
reader = VscsiReader("{}/trace.vscsi".format(DAT_FOLDER))
cH = CHeatmap()
bpr = cH.get_breakpoints(reader, 'r', time_interval=1000000)
self.assertEqual(bpr[10], 53)
bpr = cH.get_breakpoints(reader, 'r', num_of_pixel_of_time_dim=1000)
bpv = cH.get_breakpoints(reader, 'v', time_interval=1000)
self.assertEqual(bpv[10], 10000)
cH.heatmap(reader, 'r', "hr_st_et",
time_interval=10000000, num_of_threads=os.cpu_count(),
cache_size=200, figname="vReader_hr_st_et_LRU.png")
cH.heatmap(reader, 'r', "hr_st_size",
enable_ihr=True,
time_interval=10000000, num_of_threads=os.cpu_count(),
cache_size=200, figname="vReader_ihr_st_size.png")
cH.heatmap(reader, 'r', "rd_distribution",
time_interval=10000000, num_of_threads=os.cpu_count(),
figname="vReader_rd_dist.png")
cH.heatmap(reader, 'r', "future_rd_distribution",
time_interval=10000000, num_of_threads=os.cpu_count(),
figname="vReader_frd_dist.png")
cH.heatmap(reader, 'r', "hit_ratio_start_time_end_time",
time_interval=10000000, algorithm="FIFO",
num_of_threads=os.cpu_count(), cache_size=2000,
figname="vReader_hr_st_et_FIFO.png")
cH.diff_heatmap(reader, 'r', "hit_ratio_start_time_end_time",
cache_size=200, time_interval=100000000,
algorithm1="LRU", algorithm2="Optimal",
cache_params2=None, num_of_threads=os.cpu_count(),
figname="vReader_diff_hr_st_et.png")
def test5_bReader(self):
print("bReader")
reader = BinaryReader("{}/trace.vscsi".format(DAT_FOLDER),
init_params={"label":6, "real_time":7, "fmt": "<3I2H2Q"})
cH = CHeatmap()
bpr = cH.get_breakpoints(reader, 'r', time_interval=1000000)
self.assertEqual(bpr[10], 53)
bpv = cH.get_breakpoints(reader, 'v', time_interval=1000)
self.assertEqual(bpv[10], 10000)
cH.heatmap(reader, 'r', "hit_ratio_start_time_end_time",
num_of_pixel_of_time_dim=100, num_of_threads=os.cpu_count(), cache_size=2000,
figname="hr_st_et_LRU_bReader.png")
cH.heatmap(reader, 'r', "rd_distribution",
num_of_pixel_of_time_dim=1000, num_of_threads=os.cpu_count())
cH.heatmap(reader, 'r', "future_rd_distribution",
num_of_pixel_of_time_dim=1000, num_of_threads=os.cpu_count())
cH.heatmap(reader, 'r', "hit_ratio_start_time_end_time",
num_of_pixel_of_time_dim=100, algorithm="FIFO",
num_of_threads=os.cpu_count(), cache_size=200)
cH.diff_heatmap(reader, 'r', "hit_ratio_start_time_end_time",
num_of_pixel_of_time_dim=24, cache_size=200,
algorithm1="LRU", algorithm2="Optimal",
cache_params2=None, num_of_threads=os.cpu_count())
def test3_c_reader_v(self):
print("test3 c_reader v")
reader = CsvReader("{}/trace.csv".format(DAT_FOLDER),
init_params={
"header": True,
"label": 5
})
cH = CHeatmap()
bpv = cH.get_breakpoints(reader, 'v', time_interval=1000)
self.assertEqual(bpv[10], 10000)
# cH.heatmap(reader, 'v', "hit_ratio_start_time_end_time",
# num_of_pixel_of_time_dim=24,
# num_of_threads=os.cpu_count(), cache_size=2000,
# figname="hr_st_et_LRU_c_reader_v.png")
cH.heatmap(reader,
'v',
"rd_distribution",
num_of_pixel_of_time_dim=200,
num_of_threads=os.cpu_count(),
figname="c_reader_rd_dist.png")
cH.heatmap(reader,
'v',
"rd_distribution_CDF",
num_of_pixel_of_time_dim=1000,
num_of_threads=os.cpu_count(),
figname="c_reader_rd_CDF_dist.png")
cH.heatmap(reader,
'v',
"future_rd_distribution",
num_of_pixel_of_time_dim=1000,
num_of_threads=os.cpu_count(),
figname="c_reader_frd_dist.png")
cH.heatmap(reader,
'v',
"hit_ratio_start_time_end_time",
num_of_pixel_of_time_dim=24,
algorithm="FIFO",
num_of_threads=os.cpu_count(),
cache_size=2000,
figname="c_reader_hr_st_et_FIFO.png")
cH.diff_heatmap(reader,
'v',
"hit_ratio_start_time_end_time",
time_interval=10000,
cache_size=200,
algorithm1="SLRU",
algorithm2="Optimal",
cache_params2=None,
num_of_threads=os.cpu_count())
def test4_c_reader_r(self):
print("test4 c_reader r")
reader = CsvReader("{}/trace.csv".format(DAT_FOLDER),
init_params={
"header": True,
"label": 5,
'real_time': 2
})
cH = CHeatmap()
bpr = cH.get_breakpoints(reader, 'r', time_interval=1000000)
self.assertEqual(bpr[10], 53)
cH.heatmap(reader,
'r',
"hit_ratio_start_time_end_time",
num_of_pixel_of_time_dim=24,
num_of_threads=os.cpu_count(),
cache_size=2000,
figname="hr_st_et_LRU_c_reader_r.png")
cH.heatmap(reader,
'r',
"rd_distribution",
num_of_pixel_of_time_dim=1000,
num_of_threads=os.cpu_count())
cH.heatmap(reader,
'r',
"future_rd_distribution",
num_of_pixel_of_time_dim=1000,
num_of_threads=os.cpu_count())
cH.heatmap(reader,
'r',
"hit_ratio_start_time_end_time",
num_of_pixel_of_time_dim=100,
algorithm="FIFO",
num_of_threads=os.cpu_count(),
cache_size=2000)
cH.diff_heatmap(reader,
'r',
"hit_ratio_start_time_end_time",
time_interval=100000000,
cache_size=200,
algorithm1="LFUFast",
algorithm2="Optimal",
cache_params2=None,
num_of_threads=os.cpu_count())
def test3_c_reader_v(self):
print("test3 c_reader v")
reader = CsvReader("{}/trace.csv".format(DAT_FOLDER),
init_params={"header":True, "label":5})
cH = CHeatmap()
bpv = cH.get_breakpoints(reader, 'v', time_interval=1000)
self.assertEqual(bpv[10], 10000)
# cH.heatmap(reader, 'v', "hit_ratio_start_time_end_time",
# num_of_pixel_of_time_dim=24,
# num_of_threads=os.cpu_count(), cache_size=2000,
# figname="hr_st_et_LRU_c_reader_v.png")
cH.heatmap(reader, 'v', "rd_distribution",
num_of_pixel_of_time_dim=200,
num_of_threads=os.cpu_count(),
figname="c_reader_rd_dist.png")
cH.heatmap(reader, 'v', "rd_distribution_CDF",
num_of_pixel_of_time_dim=1000,
num_of_threads=os.cpu_count(),
figname="c_reader_rd_CDF_dist.png")
cH.heatmap(reader, 'v', "future_rd_distribution",
num_of_pixel_of_time_dim=1000,
num_of_threads=os.cpu_count(),
figname="c_reader_frd_dist.png")
cH.heatmap(reader, 'v', "hit_ratio_start_time_end_time",
num_of_pixel_of_time_dim=24, algorithm="FIFO",
num_of_threads=os.cpu_count(), cache_size=2000,
figname="c_reader_hr_st_et_FIFO.png")
cH.diff_heatmap(reader, 'v', "hit_ratio_start_time_end_time",
time_interval=10000, cache_size=200,
algorithm1="SLRU", algorithm2="Optimal",
cache_params2=None, num_of_threads=os.cpu_count())
def test4_c_reader_r(self):
print("test4 c_reader r")
reader = CsvReader("{}/trace.csv".format(DAT_FOLDER),
init_params={"header":True, "label":5, 'real_time':2})
cH = CHeatmap()
bpr = cH.get_breakpoints(reader, 'r', time_interval=1000000)
self.assertEqual(bpr[10], 53)
cH.heatmap(reader, 'r', "hit_ratio_start_time_end_time",
num_of_pixel_of_time_dim=24, num_of_threads=os.cpu_count(), cache_size=2000,
figname="hr_st_et_LRU_c_reader_r.png")
cH.heatmap(reader, 'r', "rd_distribution",
num_of_pixel_of_time_dim=1000, num_of_threads=os.cpu_count())
cH.heatmap(reader, 'r', "future_rd_distribution",
num_of_pixel_of_time_dim=1000, num_of_threads=os.cpu_count())
cH.heatmap(reader, 'r', "hit_ratio_start_time_end_time",
num_of_pixel_of_time_dim=100, algorithm="FIFO",
num_of_threads=os.cpu_count(), cache_size=2000)
cH.diff_heatmap(reader, 'r', "hit_ratio_start_time_end_time",
time_interval=100000000, cache_size=200,
algorithm1="LFUFast", algorithm2="Optimal",
cache_params2=None, num_of_threads=os.cpu_count())
def diff_heatmap(self, time_mode, plot_type, algorithm1="LRU", time_interval=-1, num_of_pixels=-1,
algorithm2="Optimal", cache_params1=None, cache_params2=None, cache_size=-1, **kwargs):
"""
Plot the differential heatmap between two algorithms by alg2 - alg1
:param cache_size: size of cache
:param time_mode: time time_mode "v" for virutal time, "r" for real time
:param plot_type: same as the name in heatmap function
:param algorithm1: name of the first alg
:param time_interval: same as in heatmap
:param num_of_pixels: same as in heatmap
:param algorithm2: name of the second algorithm
:param cache_params1: parameters of the first algorithm
:param cache_params2: parameters of the second algorithm
:param kwargs: include num_of_threads
"""
figname = kwargs.get("figname", 'differential_heatmap.png')
num_of_threads = kwargs.get("num_of_threads", DEF_NUM_THREADS)
assert self.reader is not None, "you haven't opened a trace yet"
assert cache_size != -1, "you didn't provide size for cache"
assert cache_size <= self.num_of_req(), \
"you cannot specify cache size({}) larger than " \
"trace length({})".format(cache_size, self.num_of_req())
if algorithm1.lower() in C_AVAIL_CACHE and algorithm2.lower() in C_AVAIL_CACHE:
hm = CHeatmap()
hm.diff_heatmap(self.reader, time_mode, plot_type,
cache_size=cache_size,
time_interval=time_interval,
num_of_pixels=num_of_pixels,
algorithm1=CACHE_NAME_CONVRETER[algorithm1.lower()],
algorithm2=CACHE_NAME_CONVRETER[algorithm2.lower()],
cache_params1=cache_params1,
cache_params2=cache_params2,
**kwargs)
else:
hm = PyHeatmap()
if algorithm1.lower() not in C_AVAIL_CACHE:
xydict1 = hm.compute_heatmap(self.reader, time_mode, plot_type,
time_interval=time_interval,
cache_size=cache_size,
algorithm=algorithm1,
cache_params=cache_params1,
**kwargs)[0]
else:
xydict1 = c_heatmap.heatmap(self.reader.c_reader, time_mode, plot_type,
cache_size=cache_size,
time_interval=time_interval,
algorithm=algorithm1,
cache_params=cache_params1,
num_of_threads=num_of_threads)
if algorithm2.lower() not in C_AVAIL_CACHE:
xydict2 = hm.compute_heatmap(self.reader, time_mode, plot_type,
time_interval=time_interval,
cache_size=cache_size,
algorithm=algorithm2,
cache_params=cache_params2,
**kwargs)[0]
else:
xydict2 = c_heatmap.heatmap(self.reader.c_reader, time_mode, plot_type,
time_interval=time_interval,
cache_size=cache_size,
algorithm=algorithm2,
cache_params=cache_params2,
num_of_threads=num_of_threads)
text = "differential heatmap\ncache size: {},\ncache type: ({}-{})/{},\n" \
"time type: {},\ntime interval: {},\nplot type: \n{}".format(
cache_size, algorithm2, algorithm1, algorithm1, time_mode, time_interval, plot_type)
x1, y1 = xydict1.shape
x1, y1 = int(x1 / 2.8), y1/8
ax = plt.gca()
ax.text(x1, y1, text)
np.seterr(divide='ignore', invalid='ignore')
plot_data = (xydict2 - xydict1) / xydict1
plot_data = np.ma.array(plot_data, mask=np.tri(len(plot_data), k=-1, dtype=int).T)
plot_kwargs = {"figname": figname}
plot_kwargs["xlabel"] = plot_kwargs.get("xlabel", 'Start Time ({})'.format(time_mode))
plot_kwargs["xticks"] = plot_kwargs.get("xticks", ticker.FuncFormatter(lambda x, _: '{:.0%}'.format(x / (plot_data.shape[1]-1))))
plot_kwargs["ylabel"] = plot_kwargs.get("ylabel", "End Time ({})".format(time_mode))
plot_kwargs["yticks"] = plot_kwargs.get("yticks", ticker.FuncFormatter(lambda x, _: '{:.0%}'.format(x / (plot_data.shape[0]-1))))
plot_kwargs["imshow_kwargs"] = {"vmin": -1, "vmax": 1}
draw_heatmap(plot_data, **plot_kwargs)
def diff_heatmap(self,
time_mode,
plot_type,
algorithm1,
time_interval=-1,
num_of_pixels=-1,
algorithm2="Optimal",
cache_params1=None,
cache_params2=None,
cache_size=-1,
**kwargs):
"""
Plot the differential heatmap between two algorithms by alg2 - alg1
:param cache_size: size of cache
:param time_mode: time time_mode "v" for virutal time, "r" for real time
:param plot_type: same as the name in heatmap function
:param algorithm1: name of the first alg
:param time_interval: same as in heatmap
:param num_of_pixels: same as in heatmap
:param algorithm2: name of the second algorithm
:param cache_params1: parameters of the first algorithm
:param cache_params2: parameters of the second algorithm
:param kwargs: include num_of_threads
"""
figname = kwargs.get("figname", 'differential_heatmap.png')
num_of_threads = kwargs.get("num_of_threads", DEF_NUM_THREADS)
assert self.reader is not None, "you haven't opened a trace yet"
assert cache_size != -1, "you didn't provide size for cache"
assert cache_size <= self.num_of_req(), \
"you cannot specify cache size({}) larger than " \
"trace length({})".format(cache_size, self.num_of_req())
if algorithm1.lower() in C_AVAIL_CACHE and algorithm2.lower(
) in C_AVAIL_CACHE:
hm = CHeatmap()
hm.diff_heatmap(
self.reader,
time_mode,
plot_type,
cache_size=cache_size,
time_interval=time_interval,
num_of_pixels=num_of_pixels,
algorithm1=CACHE_NAME_CONVRETER[algorithm1.lower()],
algorithm2=CACHE_NAME_CONVRETER[algorithm2.lower()],
cache_params1=cache_params1,
cache_params2=cache_params2,
**kwargs)
else:
hm = PyHeatmap()
if algorithm1.lower() not in C_AVAIL_CACHE:
xydict1 = hm.calculate_heatmap_dat(self.reader,
time_mode,
plot_type,
time_interval=time_interval,
cache_size=cache_size,
algorithm=algorithm1,
cache_params=cache_params1,
**kwargs)[0]
else:
xydict1 = c_heatmap.heatmap(self.reader.c_reader,
time_mode,
plot_type,
cache_size=cache_size,
time_interval=time_interval,
algorithm=algorithm1,
cache_params=cache_params1,
num_of_threads=num_of_threads)
if algorithm2.lower() not in C_AVAIL_CACHE:
xydict2 = hm.calculate_heatmap_dat(self.reader,
time_mode,
plot_type,
time_interval=time_interval,
cache_size=cache_size,
algorithm=algorithm2,
cache_params=cache_params2,
**kwargs)[0]
else:
xydict2 = c_heatmap.heatmap(self.reader.c_reader,
time_mode,
plot_type,
time_interval=time_interval,
cache_size=cache_size,
algorithm=algorithm2,
cache_params=cache_params2,
num_of_threads=num_of_threads)
cHm = CHeatmap()
text = " differential heatmap\n cache size: {},\n cache type: ({}-{})/{},\n" \
" time type: {},\n time interval: {},\n plot type: \n{}".format(
cache_size, algorithm2, algorithm1, algorithm1, time_mode, time_interval, plot_type)
x1, y1 = xydict1.shape
x1 = int(x1 / 2.8)
y1 /= 8
if time_mode == 'r':
time_mode_string = "Real"
elif time_mode == "v":
time_mode_string = "Virtual"
else:
raise RuntimeError(
"unknown time time_mode {}".format(time_mode))
cHm.set_plot_params(
'x',
'{} Time'.format(time_mode_string),
xydict=xydict1,
label='Start Time ({})'.format(time_mode_string),
text=(x1, y1, text))
cHm.set_plot_params('y',
'{} Time'.format(time_mode_string),
xydict=xydict1,
label='End Time ({})'.format(time_mode_string),
fixed_range=(-1, 1))
np.seterr(divide='ignore', invalid='ignore')
plot_dict = (xydict2 - xydict1) / xydict1
cHm.draw_heatmap(plot_dict, figname=figname)