def fake_deco_by_loops_ffu(loops, func, *args, **kw):
i = 1
loops = int(loops)
while i <= loops:
tc_logger.info("***** {} *****".format(i))
set_up(level='loop', loop=i)
if test_conf["event_trace"] is True:
command = "{} {} > {} &".format(
test_conf["event_trace_home"] + "/" + "trace_enable.sh",
test_conf["device_id"],
test_conf["log_home"] + "/" + "event_trace_" + str(i) + ".log")
tc_logger.info(
"Enable event_trace with command: {}".format(command))
os.system(command)
func(*args, **kw)
tear_down(level='loop', loop=i)
if test_conf["event_trace"] is True:
command = "{} {}".format(
test_conf["event_trace_home"] + "/" + "trace_disable.sh",
test_conf["device_id"])
tc_logger.info(
"Disable event_trace with command: {}".format(command))
os.system(command)
if os.path.exists(test_conf["graceful_stop_point"]):
tc_logger.info("File exists: " + test_conf["graceful_stop_point"])
tc_logger.info("Exit loop before duration threshold")
break
i = i + 1
def fake_deco_by_loops(loops, result_file, func, *args, **kw):
i = 1
loops = int(loops)
while i <= loops:
tc_logger.info("***** {} *****".format(i))
set_up(level='loop', loop=i)
if test_conf["event_trace"] is True:
command = "{} {} > {} &".format(
test_conf["event_trace_home"] + "/" + "trace_enable.sh",
test_conf["device_id"],
test_conf["log_home"] + "/" + "event_trace_" + str(i) + ".log")
tc_logger.info(
"Enable event_trace with command: {}".format(command))
os.system(command)
result_header, result_value = func(*args, **kw)
tear_down(level='loop', loop=i)
if test_conf["event_trace"] is True:
command = "{} {}".format(
test_conf["event_trace_home"] + "/" + "trace_disable.sh",
test_conf["device_id"])
tc_logger.info(
"Disable event_trace with command: {}".format(command))
os.system(command)
result_header_copy = copy.deepcopy(result_header)
result_header_copy.insert(0, "Loop")
result_value.insert(0, str(i))
write_csv_header(result_file, result_header_copy)
write_csv_result(result_file, result_value)
if os.path.exists(test_conf["graceful_stop_point"]):
tc_logger.info("File exists: " + test_conf["graceful_stop_point"])
tc_logger.info("Exit loop before duration threshold")
break
i = i + 1
def main():
initiate_device()
initiate_file()
keep_monitor()
# config tc_logger to print in log.txt
main_log = os.path.join(test_conf['log_home'], 'log.txt')
fh = logging.FileHandler(main_log)
fh.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
tc_logger.addHandler(fh)
# import module and function
set_up(level='case')
module = import_module(test_conf['module'])
func = getattr(module, test_conf['func'])
try:
func()
except Exception as e:
raise e
finally:
if test_conf['monitor'] is True:
csv_files = [[
'monitor', test_conf['monitor_dir'] + '/monitor.csv'
]]
convert_csv_files_to_json_file(csv_files)
tear_down(level='case')
if (test_conf.get("ddtf", None) is not None):
tc_logger.removeHandler(fh)
def tc2_fio_sr_stress():
# pre_case, post_case, pre_loop and post_loop definition
tc_logger.info("Defining pre_case, post_case, pre_loop and post_loop inside of test case")
test_conf["ud_pre_case"] = ud_pre_case_string
test_conf["ud_post_case"] = ud_post_case_string
test_conf["ud_pre_loop"] = ud_pre_loop_string
test_conf["ud_post_loop"] = ud_post_loop_string
# duration configuration
if "duration" in test_conf:
duration = test_conf["duration"]
else:
duration = 300
# main function
set_up(level='case')
func = tc_run_fio_by_duration
func(block_size='512k', duration=duration, file_size='10g', runtime='600', iodepth='32', rw='read')
result = 0
# result validation
statistic_file = os.path.join(test_conf["result_home"], "statistics.csv")
statistics_column = "Read (MB/s)"
benchmark_file = _get_basic_stress_bm_filename()
benchmark_group = ["FIO", "basic", "SR"]
checkpoint_prefix = "Sequential Read"
result = stress_statistics_validation(statistic_file, statistics_column, benchmark_file,
benchmark_group, checkpoint_prefix) | result
return result
def FIO_4G_SR_Storage_Down_Perf():
# pre_case, post_case, pre_loop and post_loop definition
tc_logger.info("Defining pre_case, post_case, pre_loop and post_loop inside of test case")
test_conf["ud_pre_case"] = ud_pre_case_string
test_conf["ud_post_case"] = ud_post_case_string
test_conf["ud_pre_loop"] = ud_pre_loop_string
test_conf["ud_post_loop"] = ud_post_loop_string
# loops configration
test_conf["sub_jobs"] = _sub_jobs
test_conf["file_size"] = _file_size[1]
_loops = int(device.auto_calculate_loops()[1][0])
# main function
set_up(level='case')
func = tc_run_fio_by_loops.__wrapped__
func(iodepth=32, rw="read", block_size="512k", runtime=600, rewrite="false", loops=_loops)
# performance result verification
benchmark_item = get_benchmark_item(_get_perf_bm_filename(), ["FIO", "FIO_4G_Storage_Down_Perf"])
tc_logger.info("Benchmark is as below")
tc_logger.info(str(benchmark_item))
result_file = os.path.join(test_conf["result_home"], "fio_rpt.csv")
result = 0
# SeqRead verification
values = get_column_from_csv(result_file, "Read (MB/s)")
values = values[:-1]
checkpoints = ["Sequential Read(MB/s)" + " - " + str(i+1) for i in range(len(values))]
result = assert_values_meet_benchmark(values, benchmark_item["SR"], False, "dc.yaml", checkpoints, True) | result
return result
def tc2_IOZone_basic_Rand_3times():
# pre_case, post_case, pre_loop and post_loop definition
tc_logger.info(
"Defining pre_case, post_case, pre_loop and post_loop inside of test case"
)
test_conf["ud_pre_case"] = ud_pre_case_string
test_conf["ud_post_case"] = ud_post_case_string
test_conf["ud_pre_loop"] = ud_pre_loop_string
test_conf["ud_post_loop"] = ud_post_loop_string
# main function
set_up(level='case')
func = tc_run_iozone_by_loops.__wrapped__
func(threads=8,
file_size="128m",
block_size="4k",
sequential=False,
loops=3)
# performance result verification
benchmark_item = get_benchmark_item(_get_basic_perf_bm_filename(),
["IOZone", "basic"])
tc_logger.info("Benchmark is as below")
tc_logger.info(str(benchmark_item))
result_file = os.path.join(test_conf["result_home"], "iozone_result.csv")
result = 0
# Random Read verification
checkpoints_prefix = "Random readers(MB/s)"
values = get_column_from_csv(result_file, checkpoints_prefix)
values = values[-1:] + values[:-1]
checkpoints = [
checkpoints_prefix + " - " + str(i) for i in range(1, len(values))
]
checkpoints.insert(0, checkpoints_prefix + " - avg")
result = assert_values_meet_benchmark(values, benchmark_item["RR"], False,
"dc.yaml", checkpoints,
True) | result
# Random Reread verification
checkpoints_prefix = "Random writers(MB/s)"
values = get_column_from_csv(result_file, checkpoints_prefix)
values = values[-1:] + values[:-1]
checkpoints = [
checkpoints_prefix + " - " + str(i) for i in range(1, len(values))
]
checkpoints.insert(0, checkpoints_prefix + " - avg")
result = assert_values_meet_benchmark(values, benchmark_item["RW"], False,
"dc.yaml", checkpoints,
True) | result
# return result
return result
def tc2_FIO_basic_RandRW73_3times():
# pre_case, post_case, pre_loop and post_loop definition
tc_logger.info(
"Defining pre_case, post_case, pre_loop and post_loop inside of test case"
)
test_conf["ud_pre_case"] = ud_pre_case_string
test_conf["ud_post_case"] = ud_post_case_string
test_conf["ud_pre_loop"] = ud_pre_loop_string
test_conf["ud_post_loop"] = ud_post_loop_string
# main function
set_up(level='case')
func = tc_run_fio_by_loops.__wrapped__
func(iodepth=32,
rw="randrw",
rwmixread="70",
block_size="4k",
file_size="1g",
runtime=600,
loops=3)
# performance result verification
benchmark_item = get_benchmark_item(_get_basic_perf_bm_filename(),
["FIO", "basic_randrw73"])
tc_logger.info("Benchmark is as below")
tc_logger.info(str(benchmark_item))
result_file = os.path.join(test_conf["result_home"], "fio_rpt.csv")
result = 0
# Read verification
values = get_column_from_csv(result_file, "Read (MB/s)")
values = values[-1:] + values[:-1]
checkpoints = [
"Random Read(MB/s)" + " - " + str(i) for i in range(1, len(values))
]
checkpoints.insert(0, "Random Read(MB/s)" + " - avg")
result = assert_values_meet_benchmark(values, benchmark_item["RR"], False,
"dc.yaml", checkpoints,
True) | result
# Read verification
values = get_column_from_csv(result_file, "Write (MB/s)")
values = values[-1:] + values[:-1]
checkpoints = [
"Random Write(MB/s)" + " - " + str(i) for i in range(1, len(values))
]
checkpoints.insert(0, "Random Write(MB/s)" + " - avg")
result = assert_values_meet_benchmark(values, benchmark_item["RW"], False,
"dc.yaml", checkpoints,
True) | result
# return result
return result
def tc2_ab_default_stress():
# pre_case, post_case, pre_loop and post_loop definition
tc_logger.info("Defining pre_case, post_case, pre_loop and post_loop inside of test case")
test_conf["ud_pre_case"] = ud_pre_case_string
test_conf["ud_post_case"] = ud_post_case_string
test_conf["ud_pre_loop"] = ud_pre_loop_string
test_conf["ud_post_loop"] = ud_post_loop_string
# duration configuration
if "duration" in test_conf:
duration = test_conf["duration"]
else:
duration = 300
# main function
set_up(level='case')
func = tc_run_micro_by_duration
func(duration=duration)
result = 0
# result validation - Sequential Read
statistic_file = os.path.join(test_conf["result_home"], "statistics.csv")
statistics_column = "Sequential Read(MB/s)"
benchmark_file = _get_basic_stress_bm_filename()
benchmark_group = ["AB", "default", "SR"]
checkpoint_prefix = "Sequential Read"
result = stress_statistics_validation(statistic_file, statistics_column, benchmark_file,
benchmark_group, checkpoint_prefix) | result
# result validation - Sequential Write
statistics_column = "Sequential Write(MB/s)"
benchmark_group = ["AB", "default", "SW"]
checkpoint_prefix = "Sequential Write"
result = stress_statistics_validation(statistic_file, statistics_column, benchmark_file,
benchmark_group, checkpoint_prefix) | result
# result validation - Random Read
statistics_column = "Random Read(MB/s)"
benchmark_group = ["AB", "default", "RR"]
checkpoint_prefix = "Random Read"
result = stress_statistics_validation(statistic_file, statistics_column, benchmark_file,
benchmark_group, checkpoint_prefix) | result
# result validation - Random Write
statistics_column = "Random Write(MB/s)"
benchmark_group = ["AB", "default", "RW"]
checkpoint_prefix = "Random Write"
result = stress_statistics_validation(statistic_file, statistics_column, benchmark_file,
benchmark_group, checkpoint_prefix) | result
return result
def tc2_iozone_sequential_stress():
# pre_case, post_case, pre_loop and post_loop definition
tc_logger.info("Defining pre_case, post_case, pre_loop and post_loop inside of test case")
test_conf["ud_pre_case"] = ud_pre_case_string
test_conf["ud_post_case"] = ud_post_case_string
test_conf["ud_pre_loop"] = ud_pre_loop_string
test_conf["ud_post_loop"] = ud_post_loop_string
# duration configuration
if "duration" in test_conf:
duration = test_conf["duration"]
else:
duration = 300
# main function
set_up(level='case')
func = tc_run_iozone_by_duration
func(block_size='512k', duration=duration, file_size='128m', sequential='True', threads='8')
result = 0
# result validation - Initial Writer
statistic_file = os.path.join(test_conf["result_home"], "statistics.csv")
statistics_column = "Initial Writers(MB/s)"
benchmark_file = _get_basic_stress_bm_filename()
benchmark_group = ["IOZone", "basic", "SW"]
checkpoint_prefix = "Initial Writers"
result = stress_statistics_validation(statistic_file, statistics_column, benchmark_file,
benchmark_group, checkpoint_prefix) | result
# result validation - Initial Writer
statistics_column = "Rewriters(MB/s)"
benchmark_group = ["IOZone", "basic", "SW"]
checkpoint_prefix = "Rewriters"
result = stress_statistics_validation(statistic_file, statistics_column, benchmark_file,
benchmark_group, checkpoint_prefix) | result
# result validation - Reader
statistics_column = "Readers(MB/s)"
benchmark_group = ["IOZone", "basic", "SR"]
checkpoint_prefix = "Readers"
result = stress_statistics_validation(statistic_file, statistics_column, benchmark_file,
benchmark_group, checkpoint_prefix) | result
# result validation - Re-Reader
statistics_column = "Re-readers(MB/s)"
benchmark_group = ["IOZone", "basic", "SR"]
checkpoint_prefix = "Readers"
result = stress_statistics_validation(statistic_file, statistics_column, benchmark_file,
benchmark_group, checkpoint_prefix) | result
return result
def FIO_4G_Restore_No_enough_SW_3times():
# pre_case, post_case, pre_loop and post_loop definition
tc_logger.info(
"Defining pre_case, post_case, pre_loop and post_loop inside of test case"
)
test_conf["ud_pre_case"] = ud_pre_case_string
test_conf["ud_post_case"] = ud_post_case_string
test_conf["ud_pre_loop"] = ud_pre_loop_string
test_conf["ud_post_loop"] = ud_post_loop_string
# main function
set_up(level='case')
func = tc_run_fio_by_loops.__wrapped__
func(iodepth=32,
sub_jobs=4,
rw="write",
rewrite="false",
block_size="512k",
file_size="1g",
runtime=600,
loops=3)
# performance result verification
benchmark_item = get_benchmark_item(_get_basic_perf_bm_filename(),
["FIO", "FIO_4G_Restore_No_enough"])
tc_logger.info("Benchmark is as below")
tc_logger.info(str(benchmark_item))
result_file = os.path.join(test_conf["result_home"], "fio_rpt.csv")
result = 0
# SeqWrite verification
values = get_column_from_csv(result_file, "Write (MB/s)")
values = values[-1:] + values[:-1]
checkpoints = [
"Sequential Write(MB/s)" + " - " + str(i)
for i in range(1, len(values))
]
checkpoints.insert(0, "Sequential Write(MB/s)" + " - avg")
result = assert_values_meet_benchmark(values, benchmark_item["SW"], False,
"dc.yaml", checkpoints,
True) | result
return result
def fake_deco_by_duration(duration, func, *args, **kw):
duration = int(duration)
main_start_time = int(time.time())
main_current_time = main_start_time
i = 0
while (main_current_time - main_start_time) < duration:
i = i + 1
tc_logger.info("***** {} *****".format(i))
set_up(level='loop', loop=i)
if test_conf["event_trace"] is True:
command = "{} {} > {} &".format(
test_conf["event_trace_home"] + "/" + "trace_enable.sh",
test_conf["device_id"],
test_conf["log_home"] + "/" + "event_trace_" + str(i) + ".log")
tc_logger.info(
"Enable event_trace with command: {}".format(command))
os.system(command)
func(*args, **kw)
tear_down(level='loop', loop=i)
if test_conf["event_trace"] is True:
command = "{} {}".format(
test_conf["event_trace_home"] + "/" + "trace_disable.sh",
test_conf["device_id"])
tc_logger.info(
"Disable event_trace with command: {}".format(command))
os.system(command)
main_current_time = int(time.time())
if os.path.exists(test_conf["graceful_stop_point"]):
tc_logger.info("File exists: " + test_conf["graceful_stop_point"])
tc_logger.info("Exit loop before duration threshold")
break
tc_logger.info("Main Logic End Time = " +
time.strftime("%Y-%m-%d %H:%M:%S"))
tc_logger.info("Main Logic End Time = " + str(int(time.time())))
def tc2_AB_default_3times():
# pre_case, post_case, pre_loop and post_loop definition
tc_logger.info(
"Defining pre_case, post_case, pre_loop and post_loop inside of test case"
)
test_conf["ud_pre_case"] = ud_pre_case_string
test_conf["ud_post_case"] = ud_post_case_string
test_conf["ud_pre_loop"] = ud_pre_loop_string
test_conf["ud_post_loop"] = ud_post_loop_string
# main function
set_up(level='case')
# tc_run_micro_by_loops(loops=3)
func = tc_run_micro_by_loops.__wrapped__
func(loops=3)
# performance result verification
benchmark_item = get_benchmark_item(_get_basic_perf_bm_filename(),
["AB", "default"])
tc_logger.info("Benchmark is as below")
tc_logger.info(str(benchmark_item))
result_file = os.path.join(test_conf["result_home"],
"androbench_result.csv")
result = 0
# SR verification
checkpoints_prefix = "Sequential Read(MB/s)"
values = get_column_from_csv(result_file, checkpoints_prefix)
values = values[-1:] + values[:-1]
checkpoints = [
checkpoints_prefix + " - " + str(i) for i in range(1, len(values))
]
checkpoints.insert(0, checkpoints_prefix + " - avg")
result = assert_values_meet_benchmark(values, benchmark_item["SR"], False,
"dc.yaml", checkpoints,
True) | result
# SW verification
checkpoints_prefix = "Sequential Write(MB/s)"
values = get_column_from_csv(result_file, checkpoints_prefix)
values = values[-1:] + values[:-1]
checkpoints = [
checkpoints_prefix + " - " + str(i) for i in range(1, len(values))
]
checkpoints.insert(0, checkpoints_prefix + " - avg")
result = assert_values_meet_benchmark(values, benchmark_item["SW"], False,
"dc.yaml", checkpoints,
True) | result
# RR verification
checkpoints_prefix = "Random Read(MB/s)"
values = get_column_from_csv(result_file, checkpoints_prefix)
values = values[-1:] + values[:-1]
checkpoints = [
checkpoints_prefix + " - " + str(i) for i in range(1, len(values))
]
checkpoints.insert(0, checkpoints_prefix + " - avg")
result = assert_values_meet_benchmark(values, benchmark_item["RR"], False,
"dc.yaml", checkpoints,
True) | result
# RW verification
checkpoints_prefix = "Random Write(MB/s)"
values = get_column_from_csv(result_file, checkpoints_prefix)
values = values[-1:] + values[:-1]
checkpoints = [
checkpoints_prefix + " - " + str(i) for i in range(1, len(values))
]
checkpoints.insert(0, checkpoints_prefix + " - avg")
result = assert_values_meet_benchmark(values, benchmark_item["RW"], False,
"dc.yaml", checkpoints,
True) | result
# return result
return result
def IOzone_Seq_4G_Restore_No_enough_3times():
# pre_case, post_case, pre_loop and post_loop definition
tc_logger.info(
"Defining pre_case, post_case, pre_loop and post_loop inside of test case"
)
ud_pre_loop_string.extend([
"file_for_assistant_test:rw=write@bs=512k@size=4g@runtime=600@fio_fg=True",
"wb_avail_buf_restore_loop_check_no_enough"
])
ud_post_loop_string.remove("wb_avail_buf_restore_loop_check_no_enough")
test_conf["ud_pre_case"] = ud_pre_case_string
test_conf["ud_post_case"] = ud_post_case_string
test_conf["ud_pre_loop"] = ud_pre_loop_string
test_conf["ud_post_loop"] = ud_post_loop_string
# main function
set_up(level='case')
func = tc_run_iozone_by_loops.__wrapped__
func(threads=4,
file_size="1024m",
block_size="512k",
sequential=True,
loops=3)
# performance result verification
benchmark_item = get_benchmark_item(
_get_basic_perf_bm_filename(),
["IOZone", "IOzone_Seq_4G_Restore_No_enough"])
tc_logger.info("Benchmark is as below")
tc_logger.info(str(benchmark_item))
result_file = os.path.join(test_conf["result_home"], "iozone_result.csv")
result = 0
# Initial Write verification
checkpoints_prefix = "Initial Writers(MB/s)"
values = get_column_from_csv(result_file, checkpoints_prefix)
values = values[-1:] + values[:-1]
checkpoints = [
checkpoints_prefix + " - " + str(i) for i in range(1, len(values))
]
checkpoints.insert(0, checkpoints_prefix + " - avg")
result = assert_values_meet_benchmark(values, benchmark_item["SW_Initial"],
False, "dc.yaml", checkpoints,
True) | result
# Rewrite verification
checkpoints_prefix = "Rewriters(MB/s)"
values = get_column_from_csv(result_file, checkpoints_prefix)
values = values[-1:] + values[:-1]
checkpoints = [
checkpoints_prefix + " - " + str(i) for i in range(1, len(values))
]
checkpoints.insert(0, checkpoints_prefix + " - avg")
result = assert_values_meet_benchmark(
values, benchmark_item["SW_Rewriters"], False, "dc.yaml", checkpoints,
True) | result
# Read verification
checkpoints_prefix = "Readers(MB/s)"
values = get_column_from_csv(result_file, checkpoints_prefix)
values = values[-1:] + values[:-1]
checkpoints = [
checkpoints_prefix + " - " + str(i) for i in range(1, len(values))
]
checkpoints.insert(0, checkpoints_prefix + " - avg")
result = assert_values_meet_benchmark(values, benchmark_item["SR_Readers"],
False, "dc.yaml", checkpoints,
True) | result
# Reread verification
checkpoints_prefix = "Re-readers(MB/s)"
values = get_column_from_csv(result_file, checkpoints_prefix)
values = values[-1:] + values[:-1]
checkpoints = [
checkpoints_prefix + " - " + str(i) for i in range(1, len(values))
]
checkpoints.insert(0, checkpoints_prefix + " - avg")
result = assert_values_meet_benchmark(
values, benchmark_item["SR_Re-readers"], False, "dc.yaml", checkpoints,
True) | result
return result
def tc2_wb_function_sample():
# test data and benchmark definition according to host environment
result = 0
if test_conf["chip_capacity"] == "256G":
test_data = {"fio_file_size": "25G"}
test_benchmark = {
"fio_sw_time": {
"min": 20,
"max": 60,
"comments": ["Initial Version"]
},
"abs_min": {
"min": 0,
"max": 0,
"comments": ["available buffer size should be used up"]
},
"abs_max": {
"min":
100,
"max":
100,
"comments": [
"available buffer size should be able to recover to A within limited time"
]
},
"abs_recover_time": {
"min": 0,
"max": 600,
"comments": ["Initial Version"]
},
"flush_status_after_recover_1": {
"min": 3,
"max": 3,
"comments":
["flush status should be set to 3 after abs recovered"]
},
"flush_status_after_recover_2": {
"min":
0,
"max":
0,
"comments": [
"flush status should be set to 0 after abs recovered and status read"
]
}
}
elif test_conf["chip_capacity"] == "128G":
test_data = {"fio_file_size": "13G"}
test_benchmark = {
"fio_sw_time": {
"min": 10,
"max": 30,
"comments": ["Initial Version"]
},
"abs_min": {
"min": 0,
"max": 0,
"comments": ["available buffer size should be used up"]
},
"abs_max": {
"min":
100,
"max":
100,
"comments": [
"available buffer size should be able to recover to A within limited time"
]
},
"abs_recover_time": {
"min": 0,
"max": 600,
"comments": ["Initial Version"]
},
"flush_status_after_recover_1": {
"min": 3,
"max": 3,
"comments":
["flush status should be set to 3 after abs recovered"]
},
"flush_status_after_recover_2": {
"min":
0,
"max":
0,
"comments": [
"flush status should be set to 0 after abs recovered and status read"
]
}
}
else:
raise Exception("Unsupported chip capacity: " +
test_conf["chip_capacity"])
# pre_case, post_case, pre_loop and post_loop definition
tc_logger.info(
"Defining pre_case, post_case, pre_loop and post_loop inside of test case"
)
test_conf["ud_pre_case"] = ud_pre_case_string
test_conf["ud_post_case"] = ud_post_case_string
# pre case configuration
set_up(level='case')
# adb initialization
adb = ADB(test_conf["device_id"])
device = Device(test_conf["device_id"])
# launch abs monitoring in backend
def wb_func_abs_monitor(abs_use_up_timeout=60,
abs_recover_timeout=60,
monitor_interval=1,
log_file=None):
if log_file is None:
log_file = os.path.join(test_conf["monitor_home"],
"wb_func_abs_monitor.log")
# device = Device(test_conf["device_id"])
with open(log_file, "w") as f:
f.write("monitor_start=" + str(time.time()) + os.linesep)
# monitor whether abs can be used up
time_start = time.time()
while True:
# monitor whether ads is used up
time_now = time.time()
if (time_now - time_start) > abs_use_up_timeout:
f.write("abs_use_up_ts=timeout" + os.linesep)
break
else:
abs_now = device.get_wb_avail_buf()[1][0]
f.write(abs_now + os.linesep)
if abs_now == "0%":
f.write("abs_use_up_ts=" + str(time.time()) +
os.linesep)
break
f.flush()
time.sleep(monitor_interval)
# monitor whether abs can recover to 100%
time_start = time.time()
while True:
# monitor whether ads is used up
time_now = time.time()
if (time_now - time_start) > abs_recover_timeout:
f.write("abs_recover_ts=timeout" + os.linesep)
break
else:
abs_now = device.get_wb_avail_buf()[1][0]
f.write(abs_now + os.linesep)
if abs_now == "100%":
f.write("abs_recover_ts=" + str(time.time()) +
os.linesep)
break
f.flush()
time.sleep(monitor_interval)
p = Process(target=wb_func_abs_monitor,
args=[
test_benchmark["fio_sw_time"]["max"],
test_benchmark["abs_recover_time"]["max"],
])
p.daemon = True
p.start()
# run fio command on cell phone background
cmd = "shell '/data/auto_tools/fio --direct=1 --norandommap=0 --numjobs=1 --ioengine=libaio " \
+ "--iodepth=32 --rw=write --size={} --bs=512k --runtime=600" \
+ " --name=job1 --filename=/data/auto_tools/fio_test_file'"
cmd = cmd.format(test_data["fio_file_size"])
fio_start_ts = time.time()
tc_logger.info("FIO cmd execution start timestamp: " + str(fio_start_ts))
adb.execute_adb_command(cmd)
fio_end_ts = time.time()
tc_logger.info("FIO cmd execution end timestamp: " + str(fio_end_ts))
result = assert_values_meet_benchmark([fio_end_ts - fio_start_ts],
test_benchmark["fio_sw_time"], False,
"dc.yaml", ["fio_sw_time"]) | result
# wait for abs monitoring to completed
p.join(test_benchmark["fio_sw_time"]["max"] +
test_benchmark["abs_recover_time"]["max"])
p.terminate()
# verify whether abs is used up during fio execution
monitor_log_file = os.path.join(test_conf["monitor_home"],
"wb_func_abs_monitor.log")
abs_use_up_ts_pattern = re.compile("abs_use_up_ts=(.+)")
with open(monitor_log_file, "r") as f:
for line in f.readlines():
abs_use_up_ts = abs_use_up_ts_pattern.search(line)
if abs_use_up_ts is not None:
break
else:
abs_min = line
abs_min = abs_min.split("%")[0]
result = assert_values_meet_benchmark(
[int(abs_min)], test_benchmark["abs_min"], False, "dc.yaml",
["abs_min"]) | result
# verify whether abs can fully recover
abs_recover_ts_pattern = re.compile("abs_recover_ts=(.+)")
with open(monitor_log_file, "r") as f:
for line in f.readlines():
abs_recover_ts = abs_recover_ts_pattern.search(line)
if abs_recover_ts is not None:
abs_recover_ts = abs_recover_ts.group(1)
break
else:
abs_max = line
abs_max = abs_max.split("%")[0]
result = assert_values_meet_benchmark(
[int(abs_max)], test_benchmark["abs_max"], False, "dc.yaml",
["abs_max"]) | result
# verify abs recover time consumption
if abs_recover_ts == "timeout":
abs_recover_time = -1
else:
abs_recover_time = float(abs_recover_ts) - fio_end_ts
result = assert_values_meet_benchmark(
[abs_recover_time], test_benchmark["abs_recover_time"], False,
"dc.yaml", ["abs_recover_time"]) | result
# verify flush_status_after_recover_1
flush_status_after_recover = device.get_wb_flush_status()
result = assert_values_meet_benchmark(
[flush_status_after_recover],
test_benchmark["flush_status_after_recover_1"], False, "dc.yaml",
["flush_status_after_recover_1"]) | result
# flush_status_after_recover_2
flush_status_after_recover = device.get_wb_flush_status()
result = assert_values_meet_benchmark(
[flush_status_after_recover],
test_benchmark["flush_status_after_recover_2"], False, "dc.yaml",
["flush_status_after_recover_2"]) | result
# return test case result
return result
