def test_kresults_time_series(self):
"""
Test KResults job time series
:return:
"""
# "flops": [0, 111, 0, 111],
# "durations": [1.0, 1.0, 1.0, 1.0]
# "flops": [222, 0, 0, 222],
# "durations": [1.0, 1.0, 1.0, 6.0]
# crete kresults data..
kresults_json_data = create_kresults(self.time_series_2proc)
decor_data = KResultsDecorator(workload_name="workload-1",
job_name="test_job_1")
kresults_data = KResultsJob(kresults_json_data,
decorator_data=decor_data)
# job time series
time_series = kresults_data.calc_time_series()
# check flops time series (time stamps)
self.assertEqual(time_series["flops"]["times"], [1.0, 2.0, 4.0, 9.0])
# check flops time series (values)
self.assertEqual(time_series["flops"]["values"], [222, 111, 111, 222])
# check flops time series (elapsed)
self.assertEqual(time_series["flops"]["elapsed"], [1.0, 1.0, 1.0, 6.0])
# check flops time series (ratios)
self.assertEqual(time_series["flops"]["ratios"],
[222 / 1.0, 111 / 1.0, 111 / 1.0, 222 / 6.0])
def test_parallel_job_info(self):
# parallel job
job1 = KResultsJob(self.kresult_job_1)
self.assertEqual(job1.name, None)
self.assertEqual(job1.label, None)
self.assertEqual(job1.n_cpu, 2)
self.assertEqual(job1.get_class_name({}), ["generic_class"])
self.assertEqual(job1.is_in_class("dummy_class"), False)
def test_serial_job_info(self):
# serial job
job0 = KResultsJob(self.kresult_job_0)
self.assertEqual(job0.name, None)
self.assertEqual(job0.label, None)
self.assertEqual(job0.n_cpu, 1)
self.assertEqual(job0.get_class_name({}), ["generic_class"])
self.assertEqual(job0.is_in_class("dummy_class"), False)
def test_parallel_job_time_series(self):
# serial job
job1 = KResultsJob(self.kresult_job_1)
_ts = job1.calc_time_series()
self.assertEqual(_ts["flops"]["times"], [
0.01 * 10, 0.01 * 10 + 0.01 * 20, 0.03 * 333,
0.03 * 333 + 0.03 * 666
])
self.assertEqual(_ts["flops"]["values"], [10, 20, 333, 666])
self.assertEqual(_ts["flops"]["ratios"], [
10 / (0.01 * 10), 20 / (0.01 * 20), 333 / (0.03 * 333), 666 /
(0.03 * 666)
])
self.assertEqual(_ts["flops"]["elapsed"],
[0.01 * 10, 0.01 * 20, 0.03 * 333, 0.03 * 666])
def test_sim_metadata(self):
time_series_2proc = [
{
"flops": [0, 111, 0, 111],
"bytes_read": [333.3, 0, 0, 1],
"n_read": [3, 0, 0, 1],
"bytes_write": [0, 444.4, 0, 1],
"n_write": [0, 2, 0, 1],
"durations": [1.0, 1.0, 1.0, 1.0]
},
{
"flops": [222, 0, 0, 222],
"bytes_read": [0, 0, 0, 1],
"n_read": [0, 0, 0, 1],
"bytes_write": [0, 0, 0, 1],
"n_write": [0, 0, 0, 1],
"durations": [1.0, 1.0, 1.0, 6.0]
}
]
# crete kresults data (job-0)
kresults_json_data_0 = create_kresults(time_series_2proc, creation_date="2017-07-31T01:28:42+00:00")
decor_data = KResultsDecorator(workload_name="workload_1/something_else/parallel", job_name="test_job_0")
kresults_data_0 = KResultsJob(kresults_json_data_0, decorator_data=decor_data)
# crete kresults data (job-1)
kresults_json_data_1 = create_kresults(time_series_2proc, creation_date="2017-07-31T01:28:44+00:00")
decor_data = KResultsDecorator(workload_name="workload_1/something_else/parallel", job_name="test_job_1")
kresults_data_1 = KResultsJob(kresults_json_data_1, decorator_data=decor_data)
# instantiate the sim_data object
sim_data = KResultsData(jobs=[kresults_data_0, kresults_data_1], sim_name="dummy_sim", n_procs_node=36)
# test total runtime
# 11 = 9 + 2 (9 is the total duration of cpu2 and job2 has started 2 seconds after job 1)
self.assertEqual(sim_data.runtime(), 11)
# test tmin_epochs
self.assertEqual(sim_data.tmin_epochs, min(kresults_data_0.t_start, kresults_data_1.t_start))
# test tmax_epochs
self.assertEqual(sim_data.tmax_epochs, max(kresults_data_0.t_end, kresults_data_1.t_end))
def test_parallel_job_timings(self):
# parallel job
job1 = KResultsJob(self.kresult_job_1)
end_datetime_job1 = datetime.strptime(
job1._json_data["created"], '%Y-%m-%dT%H:%M:%S+00:00').timestamp()
self.assertEqual(job1.t_end, end_datetime_job1)
self.assertEqual(job1.duration, 0.03 * 333 + 0.03 * 666)
self.assertEqual(job1.t_start,
end_datetime_job1 - (0.03 * 333 + 0.03 * 666))
def test_serial_job_timings(self):
# serial job
job0 = KResultsJob(self.kresult_job_0)
end_datetime_job1 = datetime.strptime(
job0._json_data["created"], '%Y-%m-%dT%H:%M:%S+00:00').timestamp()
self.assertEqual(job0.t_end, end_datetime_job1)
self.assertEqual(job0.duration, 25.75281 + 0.007616043)
self.assertEqual(job0.t_start,
end_datetime_job1 - (25.75281 + 0.007616043))
def test_serial_job_time_series(self):
# serial job
job0 = KResultsJob(self.kresult_job_0)
_ts = job0.calc_time_series()
self.assertEqual(_ts["flops"]["times"], [25.75281])
self.assertEqual(_ts["kb_write"]["times"], [25.75281 + 0.007616043])
self.assertEqual(_ts["n_write"]["times"], [25.75281 + 0.007616043])
self.assertEqual(_ts["flops"]["values"], [10000000000])
self.assertEqual(_ts["kb_write"]["values"], [2560000 / 1024.0])
self.assertEqual(_ts["n_write"]["values"], [10])
self.assertEqual(_ts["flops"]["ratios"], [10000000000 / 25.75281])
self.assertEqual(_ts["kb_write"]["ratios"],
[2560000 / 1024.0 / 0.007616043])
self.assertEqual(_ts["n_write"]["ratios"], [10 / 0.007616043])
self.assertEqual(_ts["flops"]["elapsed"], [25.75281])
self.assertEqual(_ts["kb_write"]["elapsed"], [0.007616043])
self.assertEqual(_ts["n_write"]["elapsed"], [0.007616043])
def test_kresults_basics(self):
"""
Test main properties of a KResults job
:return:
"""
# crete kresults data..
kresults_json_data = create_kresults(self.time_series_2proc)
decor_data = KResultsDecorator(
workload_name="workload_1/something_else/parallel",
job_name="test_job_1")
kresults_data = KResultsJob(kresults_json_data,
decorator_data=decor_data)
# time start
self.assertEqual(
datetime.strptime(kresults_json_data["created"],
'%Y-%m-%dT%H:%M:%S+00:00').timestamp(),
kresults_data.t_end)
# assert time end
self.assertEqual(
kresults_data.t_start +
max([sum(ts["durations"]) for ts in self.time_series_2proc]),
kresults_data.t_end)
# assert duration
self.assertEqual(kresults_data.t_end - kresults_data.t_start,
kresults_data.duration)
# assert ncpu
self.assertEqual(kresults_data.n_cpu, len(kresults_json_data["ranks"]))
# is in class
self.assertTrue(kresults_data.is_in_class("^workload_1/.*/parallel"))
def read_from_sim_paths(cls,
sim_path,
sim_name,
n_procs_node=None,
permissive=False):
# check n of successful jobs
if not permissive:
cls.check_n_successful_jobs(sim_path)
jobs_data = []
for job_dir in cls.iter_job_dirs(sim_path):
job_dir_rel = os.path.relpath(job_dir, start=sim_path)
print("reading data from {}..".format(job_dir_rel))
job_dir_files = os.listdir(job_dir)
kresults_file = [
f for f in job_dir_files if f.endswith(cls.res_file_ext)
]
if kresults_file:
input_file_path = os.path.join(job_dir, 'input.json')
stats_file_path = os.path.join(
job_dir, cls.res_file_root + "." + cls.res_file_ext)
# Read decorator data from input file
with open(input_file_path, 'r') as f:
json_data_input = json.load(f)
decorator = KResultsDecorator(**json_data_input["metadata"])
# Append the profiled job to the "jobs_data" structure
jobs_data.append(
KResultsJob.from_kresults_file(stats_file_path,
decorator=decorator))
# and check that the collection was successful..
if not jobs_data:
print(
"Specified path does not contain any job folder (<job-ID>..)!")
sys.exit(1)
return cls(jobs=jobs_data,
sim_name=sim_name,
sim_path=sim_path,
n_procs_node=n_procs_node)
def test_global_time_series(self):
"""
Test global time series
:return:
"""
time_series_2proc = [
{
"flops": [0, 111, 0, 111],
"bytes_read": [333.3, 0, 0, 1],
"n_read": [3, 0, 0, 1],
"bytes_write": [0, 444.4, 0, 1],
"n_write": [0, 2, 0, 1],
"durations": [1.0, 1.0, 1.0, 1.0]
},
{
"flops": [222, 0, 0, 222],
"bytes_read": [0, 0, 0, 1],
"n_read": [0, 0, 0, 1],
"bytes_write": [0, 0, 0, 1],
"n_write": [0, 0, 0, 1],
"durations": [1.0, 1.0, 1.0, 6.0]
}
]
# total float values and time stamps
# job 0:
# p0_times = [1.0, 1.0, 1.0, 1.0 ]
# p0_values = [0, 111, 0, 111 ]
# p1_times = [1.0, 1.0, 1.0, 6.0 ]
# p1_values = [222, 0, 0, 222 ]
# ===> job0:
# times = [1.0, 2.0, 4.0, 9.0]
# float = [222, 111, 111, 222]
# ---------------------------------
# ===> job1:
# times = [3.0, 4.0, 6.0, 11.0]
# float = [222, 111, 111, 222]
# ---------------------------------
# Simulation totals:
# times = [1.0, 2.0, 3.0, 4.0, 6.0, 9.0, 11.]
# float = [222, 111, 222, 222, 111, 222, 222]
# binned on t_bin_ends = [4.0, 8.0, 12.]
# tt = [4.0, 8.0, 12.]
# vv = [777, 333, 222]
# crete kresults data (job-0)
kresults_json_data_0 = create_kresults(time_series_2proc, creation_date="2017-07-31T01:28:42+00:00")
decor_data = KResultsDecorator(workload_name="workload_1/something_else/parallel", job_name="test_job_0")
kresults_data_0 = KResultsJob(kresults_json_data_0, decorator_data=decor_data)
# crete kresults data (job-1)
kresults_json_data_1 = create_kresults(time_series_2proc, creation_date="2017-07-31T01:28:44+00:00")
decor_data = KResultsDecorator(workload_name="workload_1/something_else/parallel", job_name="test_job_1")
kresults_data_1 = KResultsJob(kresults_json_data_1, decorator_data=decor_data)
# instantiate the sim_data object
sim_data = KResultsData(jobs=[kresults_data_0, kresults_data_1], sim_name="dummy_sim", n_procs_node=36)
# check global time series
times = [4.0, 8.0, 12.]
# found, calculated_time_series = sim_data.create_global_time_series(times)
found, series_dict = sim_data.create_global_time_series(times)
# check that indeed has found jobs that fall in this time range
self.assertGreater(found, 0)
# check of the binned values (see above)
self.assertEqual([v for v in series_dict["flops"]["values"]], [777, 333, 222])