| import os.path |
| import unittest |
| |
| |
| from oktest import ok, main, test |
| |
| |
| from wally.suits.io import agent |
| |
| code_test_defaults = """ |
| [defaults] |
| wait_for_previous |
| buffered=0 |
| iodepth=2 |
| RUNTIME=20 |
| |
| [sec1] |
| group_reporting |
| time_based |
| softrandommap=1 |
| filename=/tmp/xxx |
| size=5G |
| ramp_time=20 |
| runtime={RUNTIME} |
| blocksize=1m |
| rw=read |
| direct=1 |
| numjobs=1 |
| some_extra=1.2314 |
| |
| [sec2] |
| group_reporting |
| time_based |
| iodepth=1 |
| softrandommap=1 |
| filename=/tmp/xxx |
| size=5G |
| ramp_time=20 |
| runtime={RUNTIME} |
| blocksize=1m |
| rw=read |
| direct=1 |
| numjobs=1 |
| some_extra=1.2314 |
| """ |
| |
| defaults = """ |
| [defaults] |
| wait_for_previous |
| group_reporting |
| time_based |
| buffered=0 |
| iodepth=1 |
| softrandommap=1 |
| filename=/tmp/xxx |
| size=5G |
| ramp_time=20 |
| runtime=20 |
| blocksize=1m |
| rw=read |
| direct=1 |
| numjobs=1 |
| """ |
| |
| code_test_auto_params_1 = defaults + """ |
| [defaults] |
| RUNTIME=30 |
| |
| [sec1_{TEST_SUMM}] |
| ramp_time={% 20, 40 %} |
| runtime={RUNTIME} |
| blocksize={% 4k, 4m %} |
| """ |
| |
| |
| code_test_uniq = defaults + """ |
| [defaults] |
| REPCOUNT=2 |
| RUNTIME=30 |
| |
| [sec1_{TEST_SUMM}_{UNIQ} * 3] |
| |
| [sec2_{TEST_SUMM}_{UNIQ} * {REPCOUNT}] |
| """ |
| |
| code_test_cycles_default = defaults + """ |
| [defaults] |
| REPCOUNT=2 |
| RUNTIME={% 30, 60 %} |
| |
| [sec1_{TEST_SUMM}_{UNIQ} * 3] |
| runtime={RUNTIME} |
| blocksize={% 4k, 4m %} |
| """ |
| |
| |
| P = agent.parse_all_in_1 |
| |
| |
| class AgentTest(unittest.TestCase): |
| @test("test_parse_value") |
| def test_parse_value(self): |
| x = "asdfasd adsd d" |
| ok(agent.parse_value(x)) == x |
| ok(agent.parse_value("10 2")) == "10 2" |
| ok(agent.parse_value(None)).is_(None) |
| ok(agent.parse_value("10")) == 10 |
| ok(agent.parse_value("20")) == 20 |
| ok(agent.parse_value("10.1") - 10.1) < 1E-7 |
| ok(agent.parse_value("{% 10, 20 %}")) == [10, 20] |
| ok(agent.parse_value("{% 10,20 %}")) == [10, 20] |
| |
| code_test_compile_simplest = defaults + """ |
| [sec1] |
| some_extra=1.2314 |
| """ |
| |
| @test("test_compile_simplest") |
| def test_compile_simplest(self): |
| sections = P(self.code_test_compile_simplest, {}) |
| sections = list(sections) |
| |
| ok(len(sections)) == 1 |
| sec1 = sections[0] |
| ok(sec1.name) == "sec1" |
| vals = sec1.vals |
| ok(vals['wait_for_previous']).is_(None) |
| ok(vals['iodepth']) == 1 |
| ok(vals['some_extra'] - 1.2314) < 1E-7 |
| |
| code_test_params_in_defaults = defaults + """ |
| [defaults] |
| RUNTIME=20 |
| |
| [sec1] |
| runtime={RUNTIME} |
| """ |
| |
| @test("test_compile_defaults") |
| def test_compile_defaults(self): |
| sections = P(self.code_test_params_in_defaults, {}) |
| sections = list(sections) |
| |
| ok(len(sections)) == 1 |
| sec1 = sections[0] |
| ok(sec1.name) == "sec1" |
| vals = sec1.vals |
| ok(vals['wait_for_previous']).is_(None) |
| ok(vals['iodepth']) == 1 |
| ok(vals['runtime']) == 20 |
| |
| @test("test_defaults") |
| def test_defaults(self): |
| sections = P(code_test_defaults, {}) |
| sections = list(sections) |
| |
| ok(len(sections)) == 2 |
| sec1, sec2 = sections |
| |
| ok(sec1.name) == "sec1" |
| ok(sec2.name) == "sec2" |
| |
| ok(sec1.vals['wait_for_previous']).is_(None) |
| ok(sec2.vals['wait_for_previous']).is_(None) |
| |
| ok(sec1.vals['iodepth']) == 2 |
| ok(sec2.vals['iodepth']) == 1 |
| |
| ok(sec1.vals['buffered']) == 0 |
| ok(sec2.vals['buffered']) == 0 |
| |
| code_test_ext_params = defaults + """ |
| [sec1] |
| runtime={RUNTIME} |
| """ |
| |
| @test("test_external_params") |
| def test_external_params(self): |
| with self.assertRaises(KeyError): |
| sections = P(self.code_test_ext_params, {}) |
| list(sections) |
| |
| sections = P(self.code_test_ext_params, |
| {'RUNTIME': 20}) |
| sections = list(sections) |
| |
| code_test_cycle = defaults + """ |
| [sec1] |
| runtime={RUNTIME} |
| ramp_time={% 20, 40 %} |
| """ |
| |
| @test("test_cycle") |
| def test_cycle(self): |
| sections = P(self.code_test_cycle, |
| {'RUNTIME': 20}) |
| sections = list(sections) |
| ok(len(sections)) == 2 |
| ok(sections[0].vals['ramp_time']) == 20 |
| ok(sections[1].vals['ramp_time']) == 40 |
| |
| code_test_cycles = defaults + """ |
| [sec1] |
| ramp_time={% 20, 40 %} |
| runtime={RUNTIME} |
| blocksize={% 4k, 4m %} |
| """ |
| |
| @test("test_cycles") |
| def test_cycles(self): |
| sections = P(self.code_test_cycles, |
| {'RUNTIME': 20}) |
| sections = list(sections) |
| ok(len(sections)) == 4 |
| |
| combinations = [ |
| (section.vals['ramp_time'], section.vals['blocksize']) |
| for section in sections |
| ] |
| |
| combinations.sort() |
| |
| ok(combinations) == [(20, '4k'), (20, '4m'), (40, '4k'), (40, '4m')] |
| |
| @test("test_time_estimate") |
| def test_time_estimate(self): |
| sections = P(self.code_test_cycles, |
| {'RUNTIME': 20}) |
| sections = list(sections) |
| etime = agent.calculate_execution_time(sections) |
| |
| ok(etime) == 20 * 4 + 20 * 2 + 40 * 2 |
| ok(agent.sec_to_str(etime)) == "0:03:20" |
| |
| code_test_cycles2 = defaults + """ |
| [sec1 * 7] |
| ramp_time={% 20, 40 %} |
| runtime={RUNTIME} |
| blocksize={% 4k, 4m %} |
| """ |
| |
| @test("test_time_estimate") |
| def test_time_estimate_large(self): |
| sections = P(self.code_test_cycles2, |
| {'RUNTIME': 30}) |
| sections = list(sections) |
| |
| ok(sections[0].name) == 'sec1' |
| ok(len(sections)) == 7 * 4 |
| |
| etime = agent.calculate_execution_time(sections) |
| # ramptime optimization |
| expected_time = (20 + 30 + 30 * 6) * 2 |
| expected_time += (40 + 30 + 30 * 6) * 2 |
| ok(etime) == expected_time |
| |
| code_test_cycles3 = defaults + """ |
| [sec1 * 7] |
| ramp_time={% 20, 40 %} |
| runtime={RUNTIME} |
| blocksize={% 4k, 4m %} |
| |
| [sec2 * 7] |
| ramp_time={% 20, 40 %} |
| runtime={RUNTIME} |
| blocksize={% 4k, 4m %} |
| """ |
| |
| @test("test_time_estimate2") |
| def test_time_estimate_large2(self): |
| sections = P(self.code_test_cycles3, {'RUNTIME': 30}) |
| sections = list(sections) |
| |
| ok(sections[0].name) == 'sec1' |
| ok(sections[1].name) == 'sec1' |
| ok(len(sections)) == 7 * 4 * 2 |
| |
| etime = agent.calculate_execution_time(sections) |
| # ramptime optimization |
| expected_time = (20 + 30 + 30 * 6) * 2 |
| expected_time += (40 + 30 + 30 * 6) * 2 |
| ok(etime) == expected_time * 2 |
| |
| code_test_repeats = defaults + """ |
| [defaults] |
| REPCOUNT=2 |
| [sec1 * 3] |
| [sec2 * {REPCOUNT}] |
| """ |
| |
| @test("test_repeat") |
| def test_repeat(self): |
| sections = P(self.code_test_repeats, {}) |
| sections = list(sections) |
| ok(len(sections)) == 2 + 3 |
| ok(sections[0].name) == 'sec1' |
| ok(sections[1].name) == 'sec1' |
| ok(sections[2].name) == 'sec1' |
| ok(sections[3].name) == 'sec2' |
| ok(sections[4].name) == 'sec2' |
| |
| @test("test_real_tasks") |
| def test_real_tasks(self): |
| tasks_dir = os.path.dirname(agent.__file__) |
| fname = os.path.join(tasks_dir, 'io_scenario_ceph.cfg') |
| fc = open(fname).read() |
| |
| sections = P(fc, {'FILENAME': '/dev/null'}) |
| sections = list(sections) |
| |
| ok(len(sections)) == 7 * 9 * 4 + 7 |
| |
| etime = agent.calculate_execution_time(sections) |
| # ramptime optimization |
| expected_time = (60 * 7 + 30) * 9 * 4 + (60 * 7 + 30) |
| ok(etime) == expected_time |
| |
| if __name__ == '__main__': |
| main() |
| |
| # def do_run_fio_fake(bconf): |
| # def estimate_iops(sz, bw, lat): |
| # return 1 / (lat + float(sz) / bw) |
| # global count |
| # count += 1 |
| # parsed_out = [] |
| |
| # BW = 120.0 * (1024 ** 2) |
| # LAT = 0.003 |
| |
| # for name, cfg in bconf: |
| # sz = to_bytes(cfg['blocksize']) |
| # curr_lat = LAT * ((random.random() - 0.5) * 0.1 + 1) |
| # curr_ulat = curr_lat * 1000000 |
| # curr_bw = BW * ((random.random() - 0.5) * 0.1 + 1) |
| # iops = estimate_iops(sz, curr_bw, curr_lat) |
| # bw = iops * sz |
| |
| # res = {'ctx': 10683, |
| # 'error': 0, |
| # 'groupid': 0, |
| # 'jobname': name, |
| # 'majf': 0, |
| # 'minf': 30, |
| # 'read': {'bw': 0, |
| # 'bw_agg': 0.0, |
| # 'bw_dev': 0.0, |
| # 'bw_max': 0, |
| # 'bw_mean': 0.0, |
| # 'bw_min': 0, |
| # 'clat': {'max': 0, |
| # 'mean': 0.0, |
| # 'min': 0, |
| # 'stddev': 0.0}, |
| # 'io_bytes': 0, |
| # 'iops': 0, |
| # 'lat': {'max': 0, 'mean': 0.0, |
| # 'min': 0, 'stddev': 0.0}, |
| # 'runtime': 0, |
| # 'slat': {'max': 0, 'mean': 0.0, |
| # 'min': 0, 'stddev': 0.0} |
| # }, |
| # 'sys_cpu': 0.64, |
| # 'trim': {'bw': 0, |
| # 'bw_agg': 0.0, |
| # 'bw_dev': 0.0, |
| # 'bw_max': 0, |
| # 'bw_mean': 0.0, |
| # 'bw_min': 0, |
| # 'clat': {'max': 0, |
| # 'mean': 0.0, |
| # 'min': 0, |
| # 'stddev': 0.0}, |
| # 'io_bytes': 0, |
| # 'iops': 0, |
| # 'lat': {'max': 0, 'mean': 0.0, |
| # 'min': 0, 'stddev': 0.0}, |
| # 'runtime': 0, |
| # 'slat': {'max': 0, 'mean': 0.0, |
| # 'min': 0, 'stddev': 0.0} |
| # }, |
| # 'usr_cpu': 0.23, |
| # 'write': {'bw': 0, |
| # 'bw_agg': 0, |
| # 'bw_dev': 0, |
| # 'bw_max': 0, |
| # 'bw_mean': 0, |
| # 'bw_min': 0, |
| # 'clat': {'max': 0, 'mean': 0, |
| # 'min': 0, 'stddev': 0}, |
| # 'io_bytes': 0, |
| # 'iops': 0, |
| # 'lat': {'max': 0, 'mean': 0, |
| # 'min': 0, 'stddev': 0}, |
| # 'runtime': 0, |
| # 'slat': {'max': 0, 'mean': 0.0, |
| # 'min': 0, 'stddev': 0.0} |
| # } |
| # } |
| |
| # if cfg['rw'] in ('read', 'randread'): |
| # key = 'read' |
| # elif cfg['rw'] in ('write', 'randwrite'): |
| # key = 'write' |
| # else: |
| # raise ValueError("Uknown op type {0}".format(key)) |
| |
| # res[key]['bw'] = bw |
| # res[key]['iops'] = iops |
| # res[key]['runtime'] = 30 |
| # res[key]['io_bytes'] = res[key]['runtime'] * bw |
| # res[key]['bw_agg'] = bw |
| # res[key]['bw_dev'] = bw / 30 |
| # res[key]['bw_max'] = bw * 1.5 |
| # res[key]['bw_min'] = bw / 1.5 |
| # res[key]['bw_mean'] = bw |
| # res[key]['clat'] = {'max': curr_ulat * 10, 'mean': curr_ulat, |
| # 'min': curr_ulat / 2, 'stddev': curr_ulat} |
| # res[key]['lat'] = res[key]['clat'].copy() |
| # res[key]['slat'] = res[key]['clat'].copy() |
| |
| # parsed_out.append(res) |
| |
| # return zip(parsed_out, bconf) |