diff --git a/testcase/libmicro/libmicro-args-mm.csv b/testcase/libmicro/libmicro-args-mm.csv new file mode 100644 index 0000000000000000000000000000000000000000..0776edf38e0a58653fcee6c8830d69ee1f5bfe8d --- /dev/null +++ b/testcase/libmicro/libmicro-args-mm.csv @@ -0,0 +1,49 @@ +工具名称,子系统,权重,tool_name,bench_name,s,l,g,T,I,B,r,w,f +libmicro,mm,0.008881,malloc,malloc_100k,100k,,10,,2000,100,,, +libmicro,mm,0.009114,malloc,malloc_100,100,,10,,50,100,,, +libmicro,mm,0.009520,malloc,malloc_10k,10k,,10,,50,100,,, +libmicro,mm,0.008890,malloc,malloc_10,10,,10,,50,100,,, +libmicro,mm,0.009544,malloc,malloc_1k,1k,,10,,100,100,,, +libmicro,mm,0.020995,malloc,malloc_1m,1m,,10,,2000,100,,, +libmicro,mm,0.008396,malloc,mallocT2_100k,100k,,10,2,10000,100,,, +libmicro,mm,0.009484,memcpy,memcpy_100k,100k,,,,1000,100,,, +libmicro,mm,0.009043,memcpy,memcpy_10k,10k,,,,800,100,,, +libmicro,mm,0.010006,memcpy,memcpy_10m,10m,,,,200,10,,, +libmicro,mm,0.009218,memcpy,memcpy_10,10,,,,10,1000,,, +libmicro,mm,0.009557,memcpy,memcpy_1k,1k,,,,500,100,,, +libmicro,mm,0.011356,memcpy,memcpy_1m,1m,,,,10,100,,, +libmicro,mm,0.009686,memset,memset_100k,100k,,,,1000,100,,, +libmicro,mm,0.010205,memset,memset_10k,10k,,,,800,100,,, +libmicro,mm,0.011166,memset,memset_10m,10m,,,,200,10,,, +libmicro,mm,0.010952,memset,memset_1m,1m,,,,2000,100,,, +libmicro,mm,0.009278,mmap,mmap_ra128k,,128k,,,20000,100,1,,anon +libmicro,mm,0.008999,mmap,mmap_rt128k,,128k,,,20000,100,1,,tmp +libmicro,mm,0.008704,mmap,mmap_ru128k,,128k,,,20000,100,1,,var +libmicro,mm,0.009705,mmap,mmap_rz128k,,128k,,,2000,100,1,,zero +libmicro,mm,0.008665,mmap,mmap_t128k,,128k,,,1000,100,,,tmp +libmicro,mm,0.009218,mmap,mmap_u128k,,128k,,,1000,100,,,var +libmicro,mm,0.009244,mmap,mmap_wa128k,,128k,,,50000,100,,1,anon +libmicro,mm,0.013677,mmap,mmap_wt128k,,128k,,,50000,100,,1,tmp +libmicro,mm,0.011003,mmap,mmap_wu128k,,128k,,,500000,100,,1,var +libmicro,mm,0.009025,mmap,mmap_wz128k,,128k,,,50000,100,,1,zero +libmicro,mm,0.011538,mmap,mmap_z128k,,128k,,,2000,100,,,zero +libmicro,mm,0.006854,mprotect,mprot_wz128k,,128k,,,1000,100,,1,zero +libmicro,mm,0.007205,munmap,unmap_a128k,,128k,,,200,100,,,anon +libmicro,mm,0.009307,munmap,unmap_ra128k,,128k,,,2000,100,1,,anon +libmicro,mm,0.010353,munmap,unmap_rt128k,,128k,,,3000,100,1,,tmp +libmicro,mm,0.011663,munmap,unmap_ru128k,,128k,,,3000,100,1,,var +libmicro,mm,0.009411,munmap,unmap_rz128k,,128k,,,2000,100,1,,zero +libmicro,mm,0.009883,munmap,unmap_t128k,,128k,,,500,100,,,tmp +libmicro,mm,0.008695,munmap,unmap_u128k,,128k,,,500,100,,,var +libmicro,mm,0.011105,munmap,unmap_wt128k,,128k,,,10000,100,,1,tmp +libmicro,mm,0.010088,munmap,unmap_wu128k,,128k,,,500000,100,,1,var +libmicro,mm,0.009175,munmap,unmap_wz128k,,128k,,,8000,100,,1,zero +libmicro,mm,0.007906,munmap,unmap_z128k,,128k,,,500,100,,,zero +libmicro,mm,0.009631,strchr,strchr_10,10,,,,100,100,,, +libmicro,mm,0.010387,strchr,strchr_1k,1k,,,,5,1000,,, +libmicro,mm,0.011001,strcmp,strcmp_10,10,,,,10,1000,,, +libmicro,mm,0.009855,strcmp,strcmp_1k,1k,,,,200,100,,, +libmicro,mm,0.008190,strcpy,strcpy_10,10,,,,100,100,,, +libmicro,mm,0.008190,strcpy,strcpy_1k,1k,,,,200,100,,, +libmicro,mm,0.008430,strlen,strlen_10,10,,,,5,1000,,, +libmicro,mm,0.011547,strlen,strlen_1k,1k,,,,100,100,,, diff --git a/testcase/libmicro/libmicro-tune-mm.csv b/testcase/libmicro/libmicro-tune-mm.csv new file mode 100644 index 0000000000000000000000000000000000000000..62cabae74cc510f06d5a3841976ea70a0cfda1ad --- /dev/null +++ b/testcase/libmicro/libmicro-tune-mm.csv @@ -0,0 +1,50 @@ +# libmicro memory 用例稳定性参数配置 +# 格式: 用例名称,warmup,run_loop,result_select_percent +tperf-libmicro-B100-I2000-T-bnmalloc_100k-f-g10-l-r-s100k-tnmalloc-w,1,10,80 +tperf-libmicro-B100-I50-T-bnmalloc_100-f-g10-l-r-s100-tnmalloc-w,1,10,80 +tperf-libmicro-B100-I50-T-bnmalloc_10k-f-g10-l-r-s10k-tnmalloc-w,1,10,80 +tperf-libmicro-B100-I50-T-bnmalloc_10-f-g10-l-r-s10-tnmalloc-w,1,10,80 +tperf-libmicro-B100-I100-T-bnmalloc_1k-f-g10-l-r-s1k-tnmalloc-w,1,10,80 +tperf-libmicro-B100-I2000-T-bnmalloc_1m-f-g10-l-r-s1m-tnmalloc-w,1,10,80 +tperf-libmicro-B100-I10000-T2-bnmallocT2_100k-f-g10-l-r-s100k-tnmalloc-w,1,10,80 +tperf-libmicro-B100-I1000-T-bnmemcpy_100k-f-g-l-r-s100k-tnmemcpy-w,1,10,80 +tperf-libmicro-B100-I800-T-bnmemcpy_10k-f-g-l-r-s10k-tnmemcpy-w,1,10,80 +tperf-libmicro-B10-I200-T-bnmemcpy_10m-f-g-l-r-s10m-tnmemcpy-w,1,10,80 +tperf-libmicro-B1000-I10-T-bnmemcpy_10-f-g-l-r-s10-tnmemcpy-w,1,10,80 +tperf-libmicro-B100-I500-T-bnmemcpy_1k-f-g-l-r-s1k-tnmemcpy-w,1,10,80 +tperf-libmicro-B100-I10-T-bnmemcpy_1m-f-g-l-r-s1m-tnmemcpy-w,1,10,80 +tperf-libmicro-B100-I1000-T-bnmemset_100k-f-g-l-r-s100k-tnmemset-w,1,10,80 +tperf-libmicro-B100-I800-T-bnmemset_10k-f-g-l-r-s10k-tnmemset-w,1,10,80 +tperf-libmicro-B10-I200-T-bnmemset_10m-f-g-l-r-s10m-tnmemset-w,1,10,80 +tperf-libmicro-B100-I2000-T-bnmemset_1m-f-g-l-r-s1m-tnmemset-w,1,10,80 +tperf-libmicro-B100-I20000-T-bnmmap_ra128k-fanon-g-l128k-r1-s-tnmmap-w,1,10,80 +tperf-libmicro-B100-I20000-T-bnmmap_rt128k-ftmp-g-l128k-r1-s-tnmmap-w,1,10,80 +tperf-libmicro-B100-I20000-T-bnmmap_ru128k-fvar-g-l128k-r1-s-tnmmap-w,1,10,80 +tperf-libmicro-B100-I2000-T-bnmmap_rz128k-fzero-g-l128k-r1-s-tnmmap-w,1,10,80 +tperf-libmicro-B100-I1000-T-bnmmap_t128k-ftmp-g-l128k-r-s-tnmmap-w,1,10,80 +tperf-libmicro-B100-I1000-T-bnmmap_u128k-fvar-g-l128k-r-s-tnmmap-w,1,10,80 +tperf-libmicro-B100-I50000-T-bnmmap_wa128k-fanon-g-l128k-r-s-tnmmap-w1,1,10,80 +tperf-libmicro-B100-I50000-T-bnmmap_wt128k-ftmp-g-l128k-r-s-tnmmap-w1,1,10,80 +tperf-libmicro-B100-I500000-T-bnmmap_wu128k-fvar-g-l128k-r-s-tnmmap-w1,1,10,80 +tperf-libmicro-B100-I50000-T-bnmmap_wz128k-fzero-g-l128k-r-s-tnmmap-w1,1,10,80 +tperf-libmicro-B100-I2000-T-bnmmap_z128k-fzero-g-l128k-r-s-tnmmap-w,1,10,80 +tperf-libmicro-B100-I1000-T-bnmprot_wz128k-fzero-g-l128k-r-s-tnmprotect-w1,1,10,80 +tperf-libmicro-B100-I200-T-bnunmap_a128k-fanon-g-l128k-r-s-tnmunmap-w,1,10,80 +tperf-libmicro-B100-I2000-T-bnunmap_ra128k-fanon-g-l128k-r1-s-tnmunmap-w,1,10,80 +tperf-libmicro-B100-I3000-T-bnunmap_rt128k-ftmp-g-l128k-r1-s-tnmunmap-w,1,10,80 +tperf-libmicro-B100-I3000-T-bnunmap_ru128k-fvar-g-l128k-r1-s-tnmunmap-w,1,10,80 +tperf-libmicro-B100-I2000-T-bnunmap_rz128k-fzero-g-l128k-r1-s-tnmunmap-w,1,10,80 +tperf-libmicro-B100-I500-T-bnunmap_t128k-ftmp-g-l128k-r-s-tnmunmap-w,1,10,80 +tperf-libmicro-B100-I500-T-bnunmap_u128k-fvar-g-l128k-r-s-tnmunmap-w,1,10,80 +tperf-libmicro-B100-I10000-T-bnunmap_wt128k-ftmp-g-l128k-r-s-tnmunmap-w1,1,10,80 +tperf-libmicro-B100-I500000-T-bnunmap_wu128k-fvar-g-l128k-r-s-tnmunmap-w1,1,10,80 +tperf-libmicro-B100-I8000-T-bnunmap_wz128k-fzero-g-l128k-r-s-tnmunmap-w1,1,10,80 +tperf-libmicro-B100-I500-T-bnunmap_z128k-fzero-g-l128k-r-s-tnmunmap-w,1,10,80 +tperf-libmicro-B100-I100-T-bnstrchr_10-f-g-l-r-s10-tnstrchr-w,1,10,80 +tperf-libmicro-B1000-I5-T-bnstrchr_1k-f-g-l-r-s1k-tnstrchr-w,1,10,80 +tperf-libmicro-B1000-I10-T-bnstrcmp_10-f-g-l-r-s10-tnstrcmp-w,1,10,80 +tperf-libmicro-B100-I200-T-bnstrcmp_1k-f-g-l-r-s1k-tnstrcmp-w,1,10,80 +tperf-libmicro-B100-I100-T-bnstrcpy_10-f-g-l-r-s10-tnstrcpy-w,1,10,80 +tperf-libmicro-B100-I200-T-bnstrcpy_1k-f-g-l-r-s1k-tnstrcpy-w,1,10,80 +tperf-libmicro-B1000-I5-T-bnstrlen_10-f-g-l-r-s10-tnstrlen-w,1,10,80 +tperf-libmicro-B100-I100-T-bnstrlen_1k-f-g-l-r-s1k-tnstrlen-w,1,10,80 diff --git a/testcase/libmicro/libmicro-tune.csv b/testcase/libmicro/libmicro-tune-sched.csv similarity index 100% rename from testcase/libmicro/libmicro-tune.csv rename to testcase/libmicro/libmicro-tune-sched.csv diff --git a/testcase/libmicro/libmicro.py b/testcase/libmicro/libmicro.py index b3efb7c8aebde5410c45de432839b44886d74996..4239d54e38f16bcc16a00c7cc0d7d0f077583f58 100644 --- a/testcase/libmicro/libmicro.py +++ b/testcase/libmicro/libmicro.py @@ -1,17 +1,21 @@ #!/usr/bin/python3 # coding: utf-8 -# Desc: libmicro pthread_create/fork 工具类，供 parse-csv2case.py 通用框架调用 +# Desc: libmicro 工具类，供 parse-csv2case.py 通用框架调用 # -# 内部委托给 lib.ts_common.PerfLibMicro，确保生成的 case -# 与老 case (tperf-libmicro-pthread-*.py / tperf-libmicro-fork-*.py) 行为完全一致。 +# 内部委托给 lib.ts_common.PerfLibMicro，支持两种参数模式： # -# CSV 参数列名与 __init__ 参数名的对应关系： -# test_name → test_name (pthread_create / fork) -# processes → processes (-P) -# threads → threads (-T) -# iterations → iterations (-B) -# count → count (-C) -# sync → sync (-S, 1=启用) +# 模式1（调度类 - libmicro-args-sched.csv）： +# test_name, processes, threads, iterations, count, sync +# +# 模式2（内存类 - libmicro-args-mm.csv）： +# tool_name, bench_name, s, l, g, T, I, B, r, w, f +# 所有参数均在 CSV 中配置，修改参数只需编辑 CSV 文件 +# +# CSV -f 列编码约定（避免文件名中出现斜杠）： +# tmp → /tmp/libmicro.{bench_name}_file +# var → /var/tmp/libmicro.{bench_name}_file +# zero → /dev/zero +# anon → MAP_ANON import os import sys @@ -26,32 +30,106 @@ sys.path.append(_suite_top_dir) from common.lib.benchmark import TSTPerf # noqa: E402 from lib.ts_common import PerfLibMicro # noqa: E402 +# -f 编码 → 实际路径 +_F_MAP = { + "anon": "MAP_ANON", + "zero": "/dev/zero", +} + + +def _decode_f(f_enc, bench_name): + """将 CSV 中的 -f 编码展开为实际路径""" + f_enc = f_enc.strip() + if not f_enc: + return "" + if f_enc in _F_MAP: + return _F_MAP[f_enc] + if f_enc == "tmp": + return f"/tmp/libmicro.{bench_name}_file" + if f_enc == "var": + return f"/var/tmp/libmicro.{bench_name}_file" + # 未知编码原样返回 + return f_enc + + +def _build_test_opt(bench_name, s, l, g, T, I, B, r, w, f): + """根据 CSV 列值动态拼接 test_opt + + 拼接顺序与老 case 完全一致： + -E -C 2000 -L -S -W -N {bench_name} + [-s size] [-l length] [-g groups] [-T threads] + [-I iters] [-r] [-w] [-B batches] [-f file] + """ + parts = ["-E", "-C", "2000", "-L", "-S", "-W", "-N", bench_name] + if s.strip(): + parts.extend(["-s", s.strip()]) + if l.strip(): + parts.extend(["-l", l.strip()]) + if g.strip(): + parts.extend(["-g", g.strip()]) + if T.strip(): + parts.extend(["-T", T.strip()]) + if I.strip(): + parts.extend(["-I", I.strip()]) + if r.strip() == "1": + parts.append("-r") + if w.strip() == "1": + parts.append("-w") + if B.strip(): + parts.extend(["-B", B.strip()]) + f_real = _decode_f(f, bench_name) + if f_real: + parts.extend(["-f", f_real]) + return " ".join(parts) + class PerfLibmicro(TSTPerf): - """libmicro pthread_create/fork 工具类 — 委托给 PerfLibMicro + """libmicro 工具类 — 委托给 PerfLibMicro - 接收 parse-csv2case.py 传入的 CSV 字符串参数， - 拼接为 test_opt 和 tool_path 后委托给 PerfLibMicro。 + 支持调度类（pthread_create/fork）和内存类（malloc/memcpy/memset/mmap等）。 """ def __init__( self, tc_name: str, - test_name: str = "pthread_create", - processes: str = "1", - threads: str = "4", - iterations: str = "5", - count: str = "10", - sync: str = "1", + # 调度类参数 + test_name: str = "", + processes: str = "", + threads: str = "", + iterations: str = "", + count: str = "", + sync: str = "", + # 内存类参数 + tool_name: str = "", + bench_name: str = "", + s: str = "", + l: str = "", + g: str = "", + T: str = "", + I: str = "", + B: str = "", + r: str = "", + w: str = "", + f: str = "", ): super().__init__() - test_opt = f"-P {processes} -T {threads} -B {iterations} -C {count}" - if str(sync).strip() == "1": - test_opt += " -S" - tool_path = f"tools/libmicro.install/build/{test_name}" + + if bench_name: + # 内存类模式：从 CSV 参数动态拼接 test_opt + test_opt = _build_test_opt(bench_name, s, l, g, T, I, B, r, w, f) + tool_path = f"tools/libmicro.install/build/{tool_name}" + label = "L0:内存" + else: + # 调度类模式：拼接参数 + test_opt = f"-P {processes} -T {threads} -B {iterations} -C {count}" + if str(sync).strip() == "1": + test_opt += " -S" + tool_path = f"tools/libmicro.install/build/{test_name}" + label = "L0:调度" + self._impl = PerfLibMicro( name=tc_name, - label="L0:调度", + label=label, test_opt=test_opt, tool_path=tool_path, ) diff --git a/testcase/libmicro/tperf-libmicro-B10-I200-T-bnmemcpy_10m-f-g-l-r-s10m-tnmemcpy-w.py b/testcase/libmicro/tperf-libmicro-B10-I200-T-bnmemcpy_10m-f-g-l-r-s10m-tnmemcpy-w.py new file mode 100755 index 0000000000000000000000000000000000000000..d1a87e18923b28c9b94520928cf08c8314e4ffcb --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B10-I200-T-bnmemcpy_10m-f-g-l-r-s10m-tnmemcpy-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 5899d39d97a63772 + @用例名称: tperf-libmicro-B10-I200-T-bnmemcpy_10m-f-g-l-r-s10m-tnmemcpy-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=memcpy,bench_name=memcpy_10m,s=10m,l=,g=,T=,I=200,B=10,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="memcpy", + bench_name="memcpy_10m", + s="10m", + l="", + g="", + T="", + I="200", + B="10", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=memcpy,bench_name=memcpy_10m,s=10m,l=,g=,T=,I=200,B=10,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B10-I200-T-bnmemset_10m-f-g-l-r-s10m-tnmemset-w.py b/testcase/libmicro/tperf-libmicro-B10-I200-T-bnmemset_10m-f-g-l-r-s10m-tnmemset-w.py new file mode 100755 index 0000000000000000000000000000000000000000..0717f1c3b1a025e70870fd9b21b879bbc3209f5a --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B10-I200-T-bnmemset_10m-f-g-l-r-s10m-tnmemset-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 147c180b0aa641bc + @用例名称: tperf-libmicro-B10-I200-T-bnmemset_10m-f-g-l-r-s10m-tnmemset-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=memset,bench_name=memset_10m,s=10m,l=,g=,T=,I=200,B=10,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="memset", + bench_name="memset_10m", + s="10m", + l="", + g="", + T="", + I="200", + B="10", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=memset,bench_name=memset_10m,s=10m,l=,g=,T=,I=200,B=10,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I10-T-bnmemcpy_1m-f-g-l-r-s1m-tnmemcpy-w.py b/testcase/libmicro/tperf-libmicro-B100-I10-T-bnmemcpy_1m-f-g-l-r-s1m-tnmemcpy-w.py new file mode 100755 index 0000000000000000000000000000000000000000..401ef040e71d7ad4e05b45960071be6255c632f0 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I10-T-bnmemcpy_1m-f-g-l-r-s1m-tnmemcpy-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 84e3ac0d22b55ea0 + @用例名称: tperf-libmicro-B100-I10-T-bnmemcpy_1m-f-g-l-r-s1m-tnmemcpy-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=memcpy,bench_name=memcpy_1m,s=1m,l=,g=,T=,I=10,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="memcpy", + bench_name="memcpy_1m", + s="1m", + l="", + g="", + T="", + I="10", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=memcpy,bench_name=memcpy_1m,s=1m,l=,g=,T=,I=10,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I100-T-bnmalloc_1k-f-g10-l-r-s1k-tnmalloc-w.py b/testcase/libmicro/tperf-libmicro-B100-I100-T-bnmalloc_1k-f-g10-l-r-s1k-tnmalloc-w.py new file mode 100755 index 0000000000000000000000000000000000000000..54520aa1a732cc95eb68425eeca5332e3fb4f8fc --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I100-T-bnmalloc_1k-f-g10-l-r-s1k-tnmalloc-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: ed18f6de0e6002ef + @用例名称: tperf-libmicro-B100-I100-T-bnmalloc_1k-f-g10-l-r-s1k-tnmalloc-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=malloc,bench_name=malloc_1k,s=1k,l=,g=10,T=,I=100,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="malloc", + bench_name="malloc_1k", + s="1k", + l="", + g="10", + T="", + I="100", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=malloc,bench_name=malloc_1k,s=1k,l=,g=10,T=,I=100,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I100-T-bnstrchr_10-f-g-l-r-s10-tnstrchr-w.py b/testcase/libmicro/tperf-libmicro-B100-I100-T-bnstrchr_10-f-g-l-r-s10-tnstrchr-w.py new file mode 100755 index 0000000000000000000000000000000000000000..59e34a8080c2ab8c7d93ed3d09dabda327473378 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I100-T-bnstrchr_10-f-g-l-r-s10-tnstrchr-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 13e6f1c6e05130e0 + @用例名称: tperf-libmicro-B100-I100-T-bnstrchr_10-f-g-l-r-s10-tnstrchr-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=strchr,bench_name=strchr_10,s=10,l=,g=,T=,I=100,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="strchr", + bench_name="strchr_10", + s="10", + l="", + g="", + T="", + I="100", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=strchr,bench_name=strchr_10,s=10,l=,g=,T=,I=100,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I100-T-bnstrcpy_10-f-g-l-r-s10-tnstrcpy-w.py b/testcase/libmicro/tperf-libmicro-B100-I100-T-bnstrcpy_10-f-g-l-r-s10-tnstrcpy-w.py new file mode 100755 index 0000000000000000000000000000000000000000..31c54b06e9d759ee064501351072e902f9137289 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I100-T-bnstrcpy_10-f-g-l-r-s10-tnstrcpy-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 289b57ac389a57ff + @用例名称: tperf-libmicro-B100-I100-T-bnstrcpy_10-f-g-l-r-s10-tnstrcpy-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=strcpy,bench_name=strcpy_10,s=10,l=,g=,T=,I=100,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="strcpy", + bench_name="strcpy_10", + s="10", + l="", + g="", + T="", + I="100", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=strcpy,bench_name=strcpy_10,s=10,l=,g=,T=,I=100,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I100-T-bnstrlen_1k-f-g-l-r-s1k-tnstrlen-w.py b/testcase/libmicro/tperf-libmicro-B100-I100-T-bnstrlen_1k-f-g-l-r-s1k-tnstrlen-w.py new file mode 100755 index 0000000000000000000000000000000000000000..2abe7f35cb2838898692f39584fb023a088fe374 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I100-T-bnstrlen_1k-f-g-l-r-s1k-tnstrlen-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: f6678cf04a27a7b0 + @用例名称: tperf-libmicro-B100-I100-T-bnstrlen_1k-f-g-l-r-s1k-tnstrlen-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=strlen,bench_name=strlen_1k,s=1k,l=,g=,T=,I=100,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="strlen", + bench_name="strlen_1k", + s="1k", + l="", + g="", + T="", + I="100", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=strlen,bench_name=strlen_1k,s=1k,l=,g=,T=,I=100,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I1000-T-bnmemcpy_100k-f-g-l-r-s100k-tnmemcpy-w.py b/testcase/libmicro/tperf-libmicro-B100-I1000-T-bnmemcpy_100k-f-g-l-r-s100k-tnmemcpy-w.py new file mode 100755 index 0000000000000000000000000000000000000000..4d04a09d7abd328e13f8cfd8b676f61a58c254c4 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I1000-T-bnmemcpy_100k-f-g-l-r-s100k-tnmemcpy-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 81b2236d9f65cdb0 + @用例名称: tperf-libmicro-B100-I1000-T-bnmemcpy_100k-f-g-l-r-s100k-tnmemcpy-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=memcpy,bench_name=memcpy_100k,s=100k,l=,g=,T=,I=1000,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="memcpy", + bench_name="memcpy_100k", + s="100k", + l="", + g="", + T="", + I="1000", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=memcpy,bench_name=memcpy_100k,s=100k,l=,g=,T=,I=1000,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I1000-T-bnmemset_100k-f-g-l-r-s100k-tnmemset-w.py b/testcase/libmicro/tperf-libmicro-B100-I1000-T-bnmemset_100k-f-g-l-r-s100k-tnmemset-w.py new file mode 100755 index 0000000000000000000000000000000000000000..a7e18e2ae35591d5fba63ad5346a033cd3845005 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I1000-T-bnmemset_100k-f-g-l-r-s100k-tnmemset-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: e8b69db694e1ce4f + @用例名称: tperf-libmicro-B100-I1000-T-bnmemset_100k-f-g-l-r-s100k-tnmemset-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=memset,bench_name=memset_100k,s=100k,l=,g=,T=,I=1000,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="memset", + bench_name="memset_100k", + s="100k", + l="", + g="", + T="", + I="1000", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=memset,bench_name=memset_100k,s=100k,l=,g=,T=,I=1000,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I1000-T-bnmmap_t128k-ftmp-g-l128k-r-s-tnmmap-w.py b/testcase/libmicro/tperf-libmicro-B100-I1000-T-bnmmap_t128k-ftmp-g-l128k-r-s-tnmmap-w.py new file mode 100755 index 0000000000000000000000000000000000000000..041e12310a3b20b39533090f36a554d524390016 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I1000-T-bnmmap_t128k-ftmp-g-l128k-r-s-tnmmap-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 17c43f90abd1b201 + @用例名称: tperf-libmicro-B100-I1000-T-bnmmap_t128k-ftmp-g-l128k-r-s-tnmmap-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=mmap,bench_name=mmap_t128k,s=,l=128k,g=,T=,I=1000,B=100,r=,w=,f=tmp + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="mmap", + bench_name="mmap_t128k", + s="", + l="128k", + g="", + T="", + I="1000", + B="100", + r="", + w="", + f="tmp", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=mmap,bench_name=mmap_t128k,s=,l=128k,g=,T=,I=1000,B=100,r=,w=,f=tmp + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I1000-T-bnmmap_u128k-fvar-g-l128k-r-s-tnmmap-w.py b/testcase/libmicro/tperf-libmicro-B100-I1000-T-bnmmap_u128k-fvar-g-l128k-r-s-tnmmap-w.py new file mode 100755 index 0000000000000000000000000000000000000000..620a60f0708181d89e0b6889b29fde387402a8c7 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I1000-T-bnmmap_u128k-fvar-g-l128k-r-s-tnmmap-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 9f256dbd01e51ee9 + @用例名称: tperf-libmicro-B100-I1000-T-bnmmap_u128k-fvar-g-l128k-r-s-tnmmap-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=mmap,bench_name=mmap_u128k,s=,l=128k,g=,T=,I=1000,B=100,r=,w=,f=var + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="mmap", + bench_name="mmap_u128k", + s="", + l="128k", + g="", + T="", + I="1000", + B="100", + r="", + w="", + f="var", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=mmap,bench_name=mmap_u128k,s=,l=128k,g=,T=,I=1000,B=100,r=,w=,f=var + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I1000-T-bnmprot_wz128k-fzero-g-l128k-r-s-tnmprotect-w1.py b/testcase/libmicro/tperf-libmicro-B100-I1000-T-bnmprot_wz128k-fzero-g-l128k-r-s-tnmprotect-w1.py new file mode 100755 index 0000000000000000000000000000000000000000..5a66ab304d4287ae3bcdb4f1c106093b8a4ba241 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I1000-T-bnmprot_wz128k-fzero-g-l128k-r-s-tnmprotect-w1.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 669f01497b38e6c3 + @用例名称: tperf-libmicro-B100-I1000-T-bnmprot_wz128k-fzero-g-l128k-r-s-tnmprotect-w1 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=mprotect,bench_name=mprot_wz128k,s=,l=128k,g=,T=,I=1000,B=100,r=,w=1,f=zero + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="mprotect", + bench_name="mprot_wz128k", + s="", + l="128k", + g="", + T="", + I="1000", + B="100", + r="", + w="1", + f="zero", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=mprotect,bench_name=mprot_wz128k,s=,l=128k,g=,T=,I=1000,B=100,r=,w=1,f=zero + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I10000-T-bnunmap_wt128k-ftmp-g-l128k-r-s-tnmunmap-w1.py b/testcase/libmicro/tperf-libmicro-B100-I10000-T-bnunmap_wt128k-ftmp-g-l128k-r-s-tnmunmap-w1.py new file mode 100755 index 0000000000000000000000000000000000000000..322db92c3b6fb59ce988f00c82ea48c314cfafc4 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I10000-T-bnunmap_wt128k-ftmp-g-l128k-r-s-tnmunmap-w1.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: f1085478eb1972cd + @用例名称: tperf-libmicro-B100-I10000-T-bnunmap_wt128k-ftmp-g-l128k-r-s-tnmunmap-w1 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=munmap,bench_name=unmap_wt128k,s=,l=128k,g=,T=,I=10000,B=100,r=,w=1,f=tmp + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="munmap", + bench_name="unmap_wt128k", + s="", + l="128k", + g="", + T="", + I="10000", + B="100", + r="", + w="1", + f="tmp", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=munmap,bench_name=unmap_wt128k,s=,l=128k,g=,T=,I=10000,B=100,r=,w=1,f=tmp + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I10000-T2-bnmallocT2_100k-f-g10-l-r-s100k-tnmalloc-w.py b/testcase/libmicro/tperf-libmicro-B100-I10000-T2-bnmallocT2_100k-f-g10-l-r-s100k-tnmalloc-w.py new file mode 100755 index 0000000000000000000000000000000000000000..eaad2b874550dbc48bf15559dd190c377661869c --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I10000-T2-bnmallocT2_100k-f-g10-l-r-s100k-tnmalloc-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 45a8f3ada460469f + @用例名称: tperf-libmicro-B100-I10000-T2-bnmallocT2_100k-f-g10-l-r-s100k-tnmalloc-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=malloc,bench_name=mallocT2_100k,s=100k,l=,g=10,T=2,I=10000,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="malloc", + bench_name="mallocT2_100k", + s="100k", + l="", + g="10", + T="2", + I="10000", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=malloc,bench_name=mallocT2_100k,s=100k,l=,g=10,T=2,I=10000,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I200-T-bnstrcmp_1k-f-g-l-r-s1k-tnstrcmp-w.py b/testcase/libmicro/tperf-libmicro-B100-I200-T-bnstrcmp_1k-f-g-l-r-s1k-tnstrcmp-w.py new file mode 100755 index 0000000000000000000000000000000000000000..d51907700cc357bef3b41cd32cbb99747fe9b0a3 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I200-T-bnstrcmp_1k-f-g-l-r-s1k-tnstrcmp-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 1a5d355452f965f6 + @用例名称: tperf-libmicro-B100-I200-T-bnstrcmp_1k-f-g-l-r-s1k-tnstrcmp-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=strcmp,bench_name=strcmp_1k,s=1k,l=,g=,T=,I=200,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="strcmp", + bench_name="strcmp_1k", + s="1k", + l="", + g="", + T="", + I="200", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=strcmp,bench_name=strcmp_1k,s=1k,l=,g=,T=,I=200,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I200-T-bnstrcpy_1k-f-g-l-r-s1k-tnstrcpy-w.py b/testcase/libmicro/tperf-libmicro-B100-I200-T-bnstrcpy_1k-f-g-l-r-s1k-tnstrcpy-w.py new file mode 100755 index 0000000000000000000000000000000000000000..29150e3c5d82abe3cf3f0c015d274743e51d8198 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I200-T-bnstrcpy_1k-f-g-l-r-s1k-tnstrcpy-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: f7e3b92e86fbeca4 + @用例名称: tperf-libmicro-B100-I200-T-bnstrcpy_1k-f-g-l-r-s1k-tnstrcpy-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=strcpy,bench_name=strcpy_1k,s=1k,l=,g=,T=,I=200,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="strcpy", + bench_name="strcpy_1k", + s="1k", + l="", + g="", + T="", + I="200", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=strcpy,bench_name=strcpy_1k,s=1k,l=,g=,T=,I=200,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I200-T-bnunmap_a128k-fanon-g-l128k-r-s-tnmunmap-w.py b/testcase/libmicro/tperf-libmicro-B100-I200-T-bnunmap_a128k-fanon-g-l128k-r-s-tnmunmap-w.py new file mode 100755 index 0000000000000000000000000000000000000000..6015b6acbe399ce5ae18acb722e74b28bc5dd0da --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I200-T-bnunmap_a128k-fanon-g-l128k-r-s-tnmunmap-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: bc12d1f74c498d4b + @用例名称: tperf-libmicro-B100-I200-T-bnunmap_a128k-fanon-g-l128k-r-s-tnmunmap-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=munmap,bench_name=unmap_a128k,s=,l=128k,g=,T=,I=200,B=100,r=,w=,f=anon + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="munmap", + bench_name="unmap_a128k", + s="", + l="128k", + g="", + T="", + I="200", + B="100", + r="", + w="", + f="anon", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=munmap,bench_name=unmap_a128k,s=,l=128k,g=,T=,I=200,B=100,r=,w=,f=anon + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnmalloc_100k-f-g10-l-r-s100k-tnmalloc-w.py b/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnmalloc_100k-f-g10-l-r-s100k-tnmalloc-w.py new file mode 100755 index 0000000000000000000000000000000000000000..cb002e3104fbe5d388124dd01196bd0151bf004f --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnmalloc_100k-f-g10-l-r-s100k-tnmalloc-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 336df2d3e5268ebb + @用例名称: tperf-libmicro-B100-I2000-T-bnmalloc_100k-f-g10-l-r-s100k-tnmalloc-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=malloc,bench_name=malloc_100k,s=100k,l=,g=10,T=,I=2000,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="malloc", + bench_name="malloc_100k", + s="100k", + l="", + g="10", + T="", + I="2000", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=malloc,bench_name=malloc_100k,s=100k,l=,g=10,T=,I=2000,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnmalloc_1m-f-g10-l-r-s1m-tnmalloc-w.py b/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnmalloc_1m-f-g10-l-r-s1m-tnmalloc-w.py new file mode 100755 index 0000000000000000000000000000000000000000..61c22061731b81eeb5b5f22cdaa04dcc68cd98ea --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnmalloc_1m-f-g10-l-r-s1m-tnmalloc-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 7e50383527ddd91c + @用例名称: tperf-libmicro-B100-I2000-T-bnmalloc_1m-f-g10-l-r-s1m-tnmalloc-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=malloc,bench_name=malloc_1m,s=1m,l=,g=10,T=,I=2000,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="malloc", + bench_name="malloc_1m", + s="1m", + l="", + g="10", + T="", + I="2000", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=malloc,bench_name=malloc_1m,s=1m,l=,g=10,T=,I=2000,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnmemset_1m-f-g-l-r-s1m-tnmemset-w.py b/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnmemset_1m-f-g-l-r-s1m-tnmemset-w.py new file mode 100755 index 0000000000000000000000000000000000000000..c0b24428b9824594a6a3a76d99469202557cfffe --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnmemset_1m-f-g-l-r-s1m-tnmemset-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 137823cdad2d550b + @用例名称: tperf-libmicro-B100-I2000-T-bnmemset_1m-f-g-l-r-s1m-tnmemset-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=memset,bench_name=memset_1m,s=1m,l=,g=,T=,I=2000,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="memset", + bench_name="memset_1m", + s="1m", + l="", + g="", + T="", + I="2000", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=memset,bench_name=memset_1m,s=1m,l=,g=,T=,I=2000,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnmmap_rz128k-fzero-g-l128k-r1-s-tnmmap-w.py b/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnmmap_rz128k-fzero-g-l128k-r1-s-tnmmap-w.py new file mode 100755 index 0000000000000000000000000000000000000000..46b6cd1064e88e39d63eb5022c82de8ce05ffee6 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnmmap_rz128k-fzero-g-l128k-r1-s-tnmmap-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 8c6609eef349393d + @用例名称: tperf-libmicro-B100-I2000-T-bnmmap_rz128k-fzero-g-l128k-r1-s-tnmmap-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=mmap,bench_name=mmap_rz128k,s=,l=128k,g=,T=,I=2000,B=100,r=1,w=,f=zero + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="mmap", + bench_name="mmap_rz128k", + s="", + l="128k", + g="", + T="", + I="2000", + B="100", + r="1", + w="", + f="zero", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=mmap,bench_name=mmap_rz128k,s=,l=128k,g=,T=,I=2000,B=100,r=1,w=,f=zero + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnmmap_z128k-fzero-g-l128k-r-s-tnmmap-w.py b/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnmmap_z128k-fzero-g-l128k-r-s-tnmmap-w.py new file mode 100755 index 0000000000000000000000000000000000000000..3e9fbe0c1049bf215e5d55ea0334fe9192fee6ba --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnmmap_z128k-fzero-g-l128k-r-s-tnmmap-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: bdbaac0abb9e8640 + @用例名称: tperf-libmicro-B100-I2000-T-bnmmap_z128k-fzero-g-l128k-r-s-tnmmap-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=mmap,bench_name=mmap_z128k,s=,l=128k,g=,T=,I=2000,B=100,r=,w=,f=zero + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="mmap", + bench_name="mmap_z128k", + s="", + l="128k", + g="", + T="", + I="2000", + B="100", + r="", + w="", + f="zero", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=mmap,bench_name=mmap_z128k,s=,l=128k,g=,T=,I=2000,B=100,r=,w=,f=zero + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnunmap_ra128k-fanon-g-l128k-r1-s-tnmunmap-w.py b/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnunmap_ra128k-fanon-g-l128k-r1-s-tnmunmap-w.py new file mode 100755 index 0000000000000000000000000000000000000000..dbee98864141af9b08ebab74c3c8bccc5d9f714d --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnunmap_ra128k-fanon-g-l128k-r1-s-tnmunmap-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 92217ff83baf01d0 + @用例名称: tperf-libmicro-B100-I2000-T-bnunmap_ra128k-fanon-g-l128k-r1-s-tnmunmap-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=munmap,bench_name=unmap_ra128k,s=,l=128k,g=,T=,I=2000,B=100,r=1,w=,f=anon + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="munmap", + bench_name="unmap_ra128k", + s="", + l="128k", + g="", + T="", + I="2000", + B="100", + r="1", + w="", + f="anon", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=munmap,bench_name=unmap_ra128k,s=,l=128k,g=,T=,I=2000,B=100,r=1,w=,f=anon + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnunmap_rz128k-fzero-g-l128k-r1-s-tnmunmap-w.py b/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnunmap_rz128k-fzero-g-l128k-r1-s-tnmunmap-w.py new file mode 100755 index 0000000000000000000000000000000000000000..90bcddc79753e3d4b8d43f867c7ff97622cb8dde --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I2000-T-bnunmap_rz128k-fzero-g-l128k-r1-s-tnmunmap-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: d90556aceea82d11 + @用例名称: tperf-libmicro-B100-I2000-T-bnunmap_rz128k-fzero-g-l128k-r1-s-tnmunmap-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=munmap,bench_name=unmap_rz128k,s=,l=128k,g=,T=,I=2000,B=100,r=1,w=,f=zero + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="munmap", + bench_name="unmap_rz128k", + s="", + l="128k", + g="", + T="", + I="2000", + B="100", + r="1", + w="", + f="zero", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=munmap,bench_name=unmap_rz128k,s=,l=128k,g=,T=,I=2000,B=100,r=1,w=,f=zero + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I20000-T-bnmmap_ra128k-fanon-g-l128k-r1-s-tnmmap-w.py b/testcase/libmicro/tperf-libmicro-B100-I20000-T-bnmmap_ra128k-fanon-g-l128k-r1-s-tnmmap-w.py new file mode 100755 index 0000000000000000000000000000000000000000..9db2c23727082f4bdbcdd4b1991e993dc99ed1d1 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I20000-T-bnmmap_ra128k-fanon-g-l128k-r1-s-tnmmap-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: e9bd209106cdf43f + @用例名称: tperf-libmicro-B100-I20000-T-bnmmap_ra128k-fanon-g-l128k-r1-s-tnmmap-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=mmap,bench_name=mmap_ra128k,s=,l=128k,g=,T=,I=20000,B=100,r=1,w=,f=anon + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="mmap", + bench_name="mmap_ra128k", + s="", + l="128k", + g="", + T="", + I="20000", + B="100", + r="1", + w="", + f="anon", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=mmap,bench_name=mmap_ra128k,s=,l=128k,g=,T=,I=20000,B=100,r=1,w=,f=anon + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I20000-T-bnmmap_rt128k-ftmp-g-l128k-r1-s-tnmmap-w.py b/testcase/libmicro/tperf-libmicro-B100-I20000-T-bnmmap_rt128k-ftmp-g-l128k-r1-s-tnmmap-w.py new file mode 100755 index 0000000000000000000000000000000000000000..b74fc0d80f5176bab7a016c2ff890d0139039c06 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I20000-T-bnmmap_rt128k-ftmp-g-l128k-r1-s-tnmmap-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: abf1e73809d08773 + @用例名称: tperf-libmicro-B100-I20000-T-bnmmap_rt128k-ftmp-g-l128k-r1-s-tnmmap-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=mmap,bench_name=mmap_rt128k,s=,l=128k,g=,T=,I=20000,B=100,r=1,w=,f=tmp + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="mmap", + bench_name="mmap_rt128k", + s="", + l="128k", + g="", + T="", + I="20000", + B="100", + r="1", + w="", + f="tmp", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=mmap,bench_name=mmap_rt128k,s=,l=128k,g=,T=,I=20000,B=100,r=1,w=,f=tmp + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I20000-T-bnmmap_ru128k-fvar-g-l128k-r1-s-tnmmap-w.py b/testcase/libmicro/tperf-libmicro-B100-I20000-T-bnmmap_ru128k-fvar-g-l128k-r1-s-tnmmap-w.py new file mode 100755 index 0000000000000000000000000000000000000000..cd259fb2d6fbbc11e183f41de0a5f929c768b4cf --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I20000-T-bnmmap_ru128k-fvar-g-l128k-r1-s-tnmmap-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 52f68ed35f2e0d85 + @用例名称: tperf-libmicro-B100-I20000-T-bnmmap_ru128k-fvar-g-l128k-r1-s-tnmmap-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=mmap,bench_name=mmap_ru128k,s=,l=128k,g=,T=,I=20000,B=100,r=1,w=,f=var + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="mmap", + bench_name="mmap_ru128k", + s="", + l="128k", + g="", + T="", + I="20000", + B="100", + r="1", + w="", + f="var", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=mmap,bench_name=mmap_ru128k,s=,l=128k,g=,T=,I=20000,B=100,r=1,w=,f=var + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I3000-T-bnunmap_rt128k-ftmp-g-l128k-r1-s-tnmunmap-w.py b/testcase/libmicro/tperf-libmicro-B100-I3000-T-bnunmap_rt128k-ftmp-g-l128k-r1-s-tnmunmap-w.py new file mode 100755 index 0000000000000000000000000000000000000000..505cd0cfa76b7c40731bb8e7be2243f59acb5c32 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I3000-T-bnunmap_rt128k-ftmp-g-l128k-r1-s-tnmunmap-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 97fe4bf2ccbc5f79 + @用例名称: tperf-libmicro-B100-I3000-T-bnunmap_rt128k-ftmp-g-l128k-r1-s-tnmunmap-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=munmap,bench_name=unmap_rt128k,s=,l=128k,g=,T=,I=3000,B=100,r=1,w=,f=tmp + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="munmap", + bench_name="unmap_rt128k", + s="", + l="128k", + g="", + T="", + I="3000", + B="100", + r="1", + w="", + f="tmp", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=munmap,bench_name=unmap_rt128k,s=,l=128k,g=,T=,I=3000,B=100,r=1,w=,f=tmp + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I3000-T-bnunmap_ru128k-fvar-g-l128k-r1-s-tnmunmap-w.py b/testcase/libmicro/tperf-libmicro-B100-I3000-T-bnunmap_ru128k-fvar-g-l128k-r1-s-tnmunmap-w.py new file mode 100755 index 0000000000000000000000000000000000000000..71a93670cc37262a70a76e0244ead4734b04a8fa --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I3000-T-bnunmap_ru128k-fvar-g-l128k-r1-s-tnmunmap-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 090dba9a47e87249 + @用例名称: tperf-libmicro-B100-I3000-T-bnunmap_ru128k-fvar-g-l128k-r1-s-tnmunmap-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=munmap,bench_name=unmap_ru128k,s=,l=128k,g=,T=,I=3000,B=100,r=1,w=,f=var + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="munmap", + bench_name="unmap_ru128k", + s="", + l="128k", + g="", + T="", + I="3000", + B="100", + r="1", + w="", + f="var", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=munmap,bench_name=unmap_ru128k,s=,l=128k,g=,T=,I=3000,B=100,r=1,w=,f=var + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I50-T-bnmalloc_10-f-g10-l-r-s10-tnmalloc-w.py b/testcase/libmicro/tperf-libmicro-B100-I50-T-bnmalloc_10-f-g10-l-r-s10-tnmalloc-w.py new file mode 100755 index 0000000000000000000000000000000000000000..0806f288cc9a7c16569fc74b0ca5cd6cf4782118 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I50-T-bnmalloc_10-f-g10-l-r-s10-tnmalloc-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 936d1ebc0270cb5a + @用例名称: tperf-libmicro-B100-I50-T-bnmalloc_10-f-g10-l-r-s10-tnmalloc-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=malloc,bench_name=malloc_10,s=10,l=,g=10,T=,I=50,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="malloc", + bench_name="malloc_10", + s="10", + l="", + g="10", + T="", + I="50", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=malloc,bench_name=malloc_10,s=10,l=,g=10,T=,I=50,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I50-T-bnmalloc_100-f-g10-l-r-s100-tnmalloc-w.py b/testcase/libmicro/tperf-libmicro-B100-I50-T-bnmalloc_100-f-g10-l-r-s100-tnmalloc-w.py new file mode 100755 index 0000000000000000000000000000000000000000..32eb0f2470ba821c40994680368ed4813bdb8532 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I50-T-bnmalloc_100-f-g10-l-r-s100-tnmalloc-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: aeb044affb2e9694 + @用例名称: tperf-libmicro-B100-I50-T-bnmalloc_100-f-g10-l-r-s100-tnmalloc-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=malloc,bench_name=malloc_100,s=100,l=,g=10,T=,I=50,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="malloc", + bench_name="malloc_100", + s="100", + l="", + g="10", + T="", + I="50", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=malloc,bench_name=malloc_100,s=100,l=,g=10,T=,I=50,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I50-T-bnmalloc_10k-f-g10-l-r-s10k-tnmalloc-w.py b/testcase/libmicro/tperf-libmicro-B100-I50-T-bnmalloc_10k-f-g10-l-r-s10k-tnmalloc-w.py new file mode 100755 index 0000000000000000000000000000000000000000..e1869010030730fe8ccb7cd22dc5aa40bf2f7888 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I50-T-bnmalloc_10k-f-g10-l-r-s10k-tnmalloc-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: cc334f304b2f5235 + @用例名称: tperf-libmicro-B100-I50-T-bnmalloc_10k-f-g10-l-r-s10k-tnmalloc-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=malloc,bench_name=malloc_10k,s=10k,l=,g=10,T=,I=50,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="malloc", + bench_name="malloc_10k", + s="10k", + l="", + g="10", + T="", + I="50", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=malloc,bench_name=malloc_10k,s=10k,l=,g=10,T=,I=50,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I500-T-bnmemcpy_1k-f-g-l-r-s1k-tnmemcpy-w.py b/testcase/libmicro/tperf-libmicro-B100-I500-T-bnmemcpy_1k-f-g-l-r-s1k-tnmemcpy-w.py new file mode 100755 index 0000000000000000000000000000000000000000..85c308b11ef5224f888f3b7e08eecf6a109859fa --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I500-T-bnmemcpy_1k-f-g-l-r-s1k-tnmemcpy-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 00711cfaa162595f + @用例名称: tperf-libmicro-B100-I500-T-bnmemcpy_1k-f-g-l-r-s1k-tnmemcpy-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=memcpy,bench_name=memcpy_1k,s=1k,l=,g=,T=,I=500,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="memcpy", + bench_name="memcpy_1k", + s="1k", + l="", + g="", + T="", + I="500", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=memcpy,bench_name=memcpy_1k,s=1k,l=,g=,T=,I=500,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I500-T-bnunmap_t128k-ftmp-g-l128k-r-s-tnmunmap-w.py b/testcase/libmicro/tperf-libmicro-B100-I500-T-bnunmap_t128k-ftmp-g-l128k-r-s-tnmunmap-w.py new file mode 100755 index 0000000000000000000000000000000000000000..5d489f41fb326209390640b898daf07b2823ba66 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I500-T-bnunmap_t128k-ftmp-g-l128k-r-s-tnmunmap-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 0ba109572a7c1eda + @用例名称: tperf-libmicro-B100-I500-T-bnunmap_t128k-ftmp-g-l128k-r-s-tnmunmap-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=munmap,bench_name=unmap_t128k,s=,l=128k,g=,T=,I=500,B=100,r=,w=,f=tmp + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="munmap", + bench_name="unmap_t128k", + s="", + l="128k", + g="", + T="", + I="500", + B="100", + r="", + w="", + f="tmp", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=munmap,bench_name=unmap_t128k,s=,l=128k,g=,T=,I=500,B=100,r=,w=,f=tmp + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I500-T-bnunmap_u128k-fvar-g-l128k-r-s-tnmunmap-w.py b/testcase/libmicro/tperf-libmicro-B100-I500-T-bnunmap_u128k-fvar-g-l128k-r-s-tnmunmap-w.py new file mode 100755 index 0000000000000000000000000000000000000000..0fc51bbb4e71abb7ee4382d7fe4f176ea0520f5e --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I500-T-bnunmap_u128k-fvar-g-l128k-r-s-tnmunmap-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: ad505015ec6ac63a + @用例名称: tperf-libmicro-B100-I500-T-bnunmap_u128k-fvar-g-l128k-r-s-tnmunmap-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=munmap,bench_name=unmap_u128k,s=,l=128k,g=,T=,I=500,B=100,r=,w=,f=var + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="munmap", + bench_name="unmap_u128k", + s="", + l="128k", + g="", + T="", + I="500", + B="100", + r="", + w="", + f="var", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=munmap,bench_name=unmap_u128k,s=,l=128k,g=,T=,I=500,B=100,r=,w=,f=var + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I500-T-bnunmap_z128k-fzero-g-l128k-r-s-tnmunmap-w.py b/testcase/libmicro/tperf-libmicro-B100-I500-T-bnunmap_z128k-fzero-g-l128k-r-s-tnmunmap-w.py new file mode 100755 index 0000000000000000000000000000000000000000..22d0c26b65bb87807775310a22b49068ed7d00b2 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I500-T-bnunmap_z128k-fzero-g-l128k-r-s-tnmunmap-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 99c89a11657d3606 + @用例名称: tperf-libmicro-B100-I500-T-bnunmap_z128k-fzero-g-l128k-r-s-tnmunmap-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=munmap,bench_name=unmap_z128k,s=,l=128k,g=,T=,I=500,B=100,r=,w=,f=zero + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="munmap", + bench_name="unmap_z128k", + s="", + l="128k", + g="", + T="", + I="500", + B="100", + r="", + w="", + f="zero", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=munmap,bench_name=unmap_z128k,s=,l=128k,g=,T=,I=500,B=100,r=,w=,f=zero + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I50000-T-bnmmap_wa128k-fanon-g-l128k-r-s-tnmmap-w1.py b/testcase/libmicro/tperf-libmicro-B100-I50000-T-bnmmap_wa128k-fanon-g-l128k-r-s-tnmmap-w1.py new file mode 100755 index 0000000000000000000000000000000000000000..a589b5d07b23f9ef98613ad2a600355d158f2695 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I50000-T-bnmmap_wa128k-fanon-g-l128k-r-s-tnmmap-w1.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 3ea681866c988f66 + @用例名称: tperf-libmicro-B100-I50000-T-bnmmap_wa128k-fanon-g-l128k-r-s-tnmmap-w1 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=mmap,bench_name=mmap_wa128k,s=,l=128k,g=,T=,I=50000,B=100,r=,w=1,f=anon + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="mmap", + bench_name="mmap_wa128k", + s="", + l="128k", + g="", + T="", + I="50000", + B="100", + r="", + w="1", + f="anon", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=mmap,bench_name=mmap_wa128k,s=,l=128k,g=,T=,I=50000,B=100,r=,w=1,f=anon + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I50000-T-bnmmap_wt128k-ftmp-g-l128k-r-s-tnmmap-w1.py b/testcase/libmicro/tperf-libmicro-B100-I50000-T-bnmmap_wt128k-ftmp-g-l128k-r-s-tnmmap-w1.py new file mode 100755 index 0000000000000000000000000000000000000000..a01e442ef9449566169dc9cad63decd364b12679 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I50000-T-bnmmap_wt128k-ftmp-g-l128k-r-s-tnmmap-w1.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 155196ca3f9cee7e + @用例名称: tperf-libmicro-B100-I50000-T-bnmmap_wt128k-ftmp-g-l128k-r-s-tnmmap-w1 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=mmap,bench_name=mmap_wt128k,s=,l=128k,g=,T=,I=50000,B=100,r=,w=1,f=tmp + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="mmap", + bench_name="mmap_wt128k", + s="", + l="128k", + g="", + T="", + I="50000", + B="100", + r="", + w="1", + f="tmp", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=mmap,bench_name=mmap_wt128k,s=,l=128k,g=,T=,I=50000,B=100,r=,w=1,f=tmp + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I50000-T-bnmmap_wz128k-fzero-g-l128k-r-s-tnmmap-w1.py b/testcase/libmicro/tperf-libmicro-B100-I50000-T-bnmmap_wz128k-fzero-g-l128k-r-s-tnmmap-w1.py new file mode 100755 index 0000000000000000000000000000000000000000..1d4ff4a9b429d02bb45a2117811119a86c844d2c --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I50000-T-bnmmap_wz128k-fzero-g-l128k-r-s-tnmmap-w1.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: c5a4254213f34ee5 + @用例名称: tperf-libmicro-B100-I50000-T-bnmmap_wz128k-fzero-g-l128k-r-s-tnmmap-w1 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=mmap,bench_name=mmap_wz128k,s=,l=128k,g=,T=,I=50000,B=100,r=,w=1,f=zero + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="mmap", + bench_name="mmap_wz128k", + s="", + l="128k", + g="", + T="", + I="50000", + B="100", + r="", + w="1", + f="zero", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=mmap,bench_name=mmap_wz128k,s=,l=128k,g=,T=,I=50000,B=100,r=,w=1,f=zero + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I500000-T-bnmmap_wu128k-fvar-g-l128k-r-s-tnmmap-w1.py b/testcase/libmicro/tperf-libmicro-B100-I500000-T-bnmmap_wu128k-fvar-g-l128k-r-s-tnmmap-w1.py new file mode 100755 index 0000000000000000000000000000000000000000..075e9fdebd0e97adf0760c01df2bb0756b3e287e --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I500000-T-bnmmap_wu128k-fvar-g-l128k-r-s-tnmmap-w1.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 932d494342647659 + @用例名称: tperf-libmicro-B100-I500000-T-bnmmap_wu128k-fvar-g-l128k-r-s-tnmmap-w1 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=mmap,bench_name=mmap_wu128k,s=,l=128k,g=,T=,I=500000,B=100,r=,w=1,f=var + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="mmap", + bench_name="mmap_wu128k", + s="", + l="128k", + g="", + T="", + I="500000", + B="100", + r="", + w="1", + f="var", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=mmap,bench_name=mmap_wu128k,s=,l=128k,g=,T=,I=500000,B=100,r=,w=1,f=var + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I500000-T-bnunmap_wu128k-fvar-g-l128k-r-s-tnmunmap-w1.py b/testcase/libmicro/tperf-libmicro-B100-I500000-T-bnunmap_wu128k-fvar-g-l128k-r-s-tnmunmap-w1.py new file mode 100755 index 0000000000000000000000000000000000000000..090e48aadfa48fdf98af77c0384d2d065c68468a --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I500000-T-bnunmap_wu128k-fvar-g-l128k-r-s-tnmunmap-w1.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 067a7eeb893c7bec + @用例名称: tperf-libmicro-B100-I500000-T-bnunmap_wu128k-fvar-g-l128k-r-s-tnmunmap-w1 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=munmap,bench_name=unmap_wu128k,s=,l=128k,g=,T=,I=500000,B=100,r=,w=1,f=var + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="munmap", + bench_name="unmap_wu128k", + s="", + l="128k", + g="", + T="", + I="500000", + B="100", + r="", + w="1", + f="var", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=munmap,bench_name=unmap_wu128k,s=,l=128k,g=,T=,I=500000,B=100,r=,w=1,f=var + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I800-T-bnmemcpy_10k-f-g-l-r-s10k-tnmemcpy-w.py b/testcase/libmicro/tperf-libmicro-B100-I800-T-bnmemcpy_10k-f-g-l-r-s10k-tnmemcpy-w.py new file mode 100755 index 0000000000000000000000000000000000000000..0eda45888d088ad1afbf07d45e958a55876c19ea --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I800-T-bnmemcpy_10k-f-g-l-r-s10k-tnmemcpy-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: f0fbbc7ca59f4a62 + @用例名称: tperf-libmicro-B100-I800-T-bnmemcpy_10k-f-g-l-r-s10k-tnmemcpy-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=memcpy,bench_name=memcpy_10k,s=10k,l=,g=,T=,I=800,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="memcpy", + bench_name="memcpy_10k", + s="10k", + l="", + g="", + T="", + I="800", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=memcpy,bench_name=memcpy_10k,s=10k,l=,g=,T=,I=800,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I800-T-bnmemset_10k-f-g-l-r-s10k-tnmemset-w.py b/testcase/libmicro/tperf-libmicro-B100-I800-T-bnmemset_10k-f-g-l-r-s10k-tnmemset-w.py new file mode 100755 index 0000000000000000000000000000000000000000..579b12faae791ea75d9b7fc3b77aa557fcc5506b --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I800-T-bnmemset_10k-f-g-l-r-s10k-tnmemset-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: c9dfd224fec4c2f9 + @用例名称: tperf-libmicro-B100-I800-T-bnmemset_10k-f-g-l-r-s10k-tnmemset-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=memset,bench_name=memset_10k,s=10k,l=,g=,T=,I=800,B=100,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="memset", + bench_name="memset_10k", + s="10k", + l="", + g="", + T="", + I="800", + B="100", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=memset,bench_name=memset_10k,s=10k,l=,g=,T=,I=800,B=100,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B100-I8000-T-bnunmap_wz128k-fzero-g-l128k-r-s-tnmunmap-w1.py b/testcase/libmicro/tperf-libmicro-B100-I8000-T-bnunmap_wz128k-fzero-g-l128k-r-s-tnmunmap-w1.py new file mode 100755 index 0000000000000000000000000000000000000000..e1ebfa3955fd5c050e56ad4554dd5223005d5306 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B100-I8000-T-bnunmap_wz128k-fzero-g-l128k-r-s-tnmunmap-w1.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: af9de0a382c729e2 + @用例名称: tperf-libmicro-B100-I8000-T-bnunmap_wz128k-fzero-g-l128k-r-s-tnmunmap-w1 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=munmap,bench_name=unmap_wz128k,s=,l=128k,g=,T=,I=8000,B=100,r=,w=1,f=zero + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="munmap", + bench_name="unmap_wz128k", + s="", + l="128k", + g="", + T="", + I="8000", + B="100", + r="", + w="1", + f="zero", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=munmap,bench_name=unmap_wz128k,s=,l=128k,g=,T=,I=8000,B=100,r=,w=1,f=zero + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B1000-I10-T-bnmemcpy_10-f-g-l-r-s10-tnmemcpy-w.py b/testcase/libmicro/tperf-libmicro-B1000-I10-T-bnmemcpy_10-f-g-l-r-s10-tnmemcpy-w.py new file mode 100755 index 0000000000000000000000000000000000000000..87b55944004af005a7671727f709fdd48f096a73 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B1000-I10-T-bnmemcpy_10-f-g-l-r-s10-tnmemcpy-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: ce35beb119e020b9 + @用例名称: tperf-libmicro-B1000-I10-T-bnmemcpy_10-f-g-l-r-s10-tnmemcpy-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=memcpy,bench_name=memcpy_10,s=10,l=,g=,T=,I=10,B=1000,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="memcpy", + bench_name="memcpy_10", + s="10", + l="", + g="", + T="", + I="10", + B="1000", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=memcpy,bench_name=memcpy_10,s=10,l=,g=,T=,I=10,B=1000,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B1000-I10-T-bnstrcmp_10-f-g-l-r-s10-tnstrcmp-w.py b/testcase/libmicro/tperf-libmicro-B1000-I10-T-bnstrcmp_10-f-g-l-r-s10-tnstrcmp-w.py new file mode 100755 index 0000000000000000000000000000000000000000..03bc8854f0f707438488938e997de5ef3b3d0bd6 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B1000-I10-T-bnstrcmp_10-f-g-l-r-s10-tnstrcmp-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 568133d674244d55 + @用例名称: tperf-libmicro-B1000-I10-T-bnstrcmp_10-f-g-l-r-s10-tnstrcmp-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=strcmp,bench_name=strcmp_10,s=10,l=,g=,T=,I=10,B=1000,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="strcmp", + bench_name="strcmp_10", + s="10", + l="", + g="", + T="", + I="10", + B="1000", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=strcmp,bench_name=strcmp_10,s=10,l=,g=,T=,I=10,B=1000,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B1000-I5-T-bnstrchr_1k-f-g-l-r-s1k-tnstrchr-w.py b/testcase/libmicro/tperf-libmicro-B1000-I5-T-bnstrchr_1k-f-g-l-r-s1k-tnstrchr-w.py new file mode 100755 index 0000000000000000000000000000000000000000..785ad51722b4026b00f053d680815742c5b61068 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B1000-I5-T-bnstrchr_1k-f-g-l-r-s1k-tnstrchr-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 4143368c9524b595 + @用例名称: tperf-libmicro-B1000-I5-T-bnstrchr_1k-f-g-l-r-s1k-tnstrchr-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=strchr,bench_name=strchr_1k,s=1k,l=,g=,T=,I=5,B=1000,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="strchr", + bench_name="strchr_1k", + s="1k", + l="", + g="", + T="", + I="5", + B="1000", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=strchr,bench_name=strchr_1k,s=1k,l=,g=,T=,I=5,B=1000,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/libmicro/tperf-libmicro-B1000-I5-T-bnstrlen_10-f-g-l-r-s10-tnstrlen-w.py b/testcase/libmicro/tperf-libmicro-B1000-I5-T-bnstrlen_10-f-g-l-r-s10-tnstrlen-w.py new file mode 100755 index 0000000000000000000000000000000000000000..816e922657514eb5179b7665933fe92a327f3a30 --- /dev/null +++ b/testcase/libmicro/tperf-libmicro-B1000-I5-T-bnstrlen_10-f-g-l-r-s10-tnstrlen-w.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.libmicro.libmicro import PerfLibmicro # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 89242e373db78aab + @用例名称: tperf-libmicro-B1000-I5-T-bnstrlen_10-f-g-l-r-s10-tnstrlen-w + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用libmicro测试mm性能，参数：tool_name=strlen,bench_name=strlen_10,s=10,l=,g=,T=,I=5,B=1000,r=,w=,f= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具libmicro运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLibmicro( + tc_name=self.tc_name, + tool_name="strlen", + bench_name="strlen_10", + s="10", + l="", + g="", + T="", + I="5", + B="1000", + r="", + w="", + f="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用libmicro工具测试性能，参数：tool_name=strlen,bench_name=strlen_10,s=10,l=,g=,T=,I=5,B=1000,r=,w=,f= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/lmbench-args-mm.csv b/testcase/lmbench/lmbench-args-mm.csv new file mode 100644 index 0000000000000000000000000000000000000000..f6b82e4ffa824910979e36af43f5895353b07cf1 --- /dev/null +++ b/testcase/lmbench/lmbench-args-mm.csv @@ -0,0 +1,20 @@ +工具名称,子系统,权重,benchmark_name,P,size,stride,mode,filepath,extra,setup +lmbench,mm,0.017959,lat_mmap,1,4096m,,,tmpfile,,dd4096m +lmbench,mm,0.012711,lat_pagefault,1,,,,tmpfile,,dd128m +lmbench,mm,0.010844,bw_mem-fwr,1,4096m,,fwr,,, +lmbench,mm,0.010415,lat_mem_rd-prefetch-on,1,256,2000,,,, +lmbench,mm,0.010316,bw_pipe,1,,,,,, +lmbench,mm,0.010209,bw_mem-unrolled-partial-bcopy-unaligned,1,2048m,,cp,,, +lmbench,mm,0.010075,lat_mem_rd-prefetch-off,1,256,2000,,,t, +lmbench,mm,0.010038,bw_mem-bzero,1,4096m,,bzero,,, +lmbench,mm,0.010018,lat_proc-shell,1,,,shell,,, +lmbench,mm,0.010009,lat_proc-fork,1,,,fork,,, +lmbench,mm,0.009907,bw_mem-libc-bcopy-unaligned,1,2048m,,bcopy,,, +lmbench,mm,0.009903,bw_mem-bcopy,1,4096m,,bcopy,,, +lmbench,mm,0.009809,bw_mem-fcp,1,4096m,,fcp,,, +lmbench,mm,0.009792,bw_mem-write,1,4096m,,fwr,,, +lmbench,mm,0.009590,bw_mem-unrolled-bcopy-unaligned,1,2048m,,fcp,,, +lmbench,mm,0.009375,bw_mem-libc-bcopy-aligned,1,2048m,,bcopy,,conflict, +lmbench,mm,0.009149,bw_mem-cp,1,4096m,,cp,,, +lmbench,mm,0.009029,bw_mem-read,1,4096m,,frd,,, +lmbench,mm,0.008865,lat_proc-exec,1,,,exec,,, diff --git a/testcase/lmbench/lmbench-tune-mm.csv b/testcase/lmbench/lmbench-tune-mm.csv new file mode 100644 index 0000000000000000000000000000000000000000..e771b55ad264261106522da6d8ce24010caf5667 --- /dev/null +++ b/testcase/lmbench/lmbench-tune-mm.csv @@ -0,0 +1,21 @@ +# lmbench memory 用例稳定性参数配置 +# 格式: 用例名称,warmup,run_loop,result_select_percent +tperf-lmbench-P1-bnlat_mmap-ex-fitmpfile-mo-sedd4096m-si4096m-st,1,10,80 +tperf-lmbench-P1-bnlat_pagefault-ex-fitmpfile-mo-sedd128m-si-st,1,10,80 +tperf-lmbench-P1-bnbw_mem-fwr-ex-fi-mofwr-se-si4096m-st,1,10,80 +tperf-lmbench-P1-bnlat_mem_rd-prefetch-on-ex-fi-mo-se-si256-st2000,0,1,100 +tperf-lmbench-P1-bnbw_pipe-ex-fi-mo-se-si-st,0,10,80 +tperf-lmbench-P1-bnbw_mem-unrolled-partial-bcopy-unaligned-ex-fi-mocp-se-si2048m-st,1,10,80 +tperf-lmbench-P1-bnlat_mem_rd-prefetch-off-ext-fi-mo-se-si256-st2000,0,1,100 +tperf-lmbench-P1-bnbw_mem-bzero-ex-fi-mobzero-se-si4096m-st,1,10,80 +tperf-lmbench-P1-bnlat_proc-shell-ex-fi-moshell-se-si-st,1,10,80 +tperf-lmbench-P1-bnlat_proc-fork-ex-fi-mofork-se-si-st,0,10,80 +tperf-lmbench-P1-bnbw_mem-libc-bcopy-unaligned-ex-fi-mobcopy-se-si2048m-st,1,10,80 +tperf-lmbench-P1-bnbw_mem-bcopy-ex-fi-mobcopy-se-si4096m-st,1,10,80 +tperf-lmbench-P1-bnbw_mem-fcp-ex-fi-mofcp-se-si4096m-st,1,10,80 +tperf-lmbench-P1-bnbw_mem-write-ex-fi-mofwr-se-si4096m-st,0,10,80 +tperf-lmbench-P1-bnbw_mem-unrolled-bcopy-unaligned-ex-fi-mofcp-se-si2048m-st,1,10,80 +tperf-lmbench-P1-bnbw_mem-libc-bcopy-aligned-exconflict-fi-mobcopy-se-si2048m-st,1,10,80 +tperf-lmbench-P1-bnbw_mem-cp-ex-fi-mocp-se-si4096m-st,1,10,80 +tperf-lmbench-P1-bnbw_mem-read-ex-fi-mofrd-se-si4096m-st,1,10,80 +tperf-lmbench-P1-bnlat_proc-exec-ex-fi-moexec-se-si-st,1,10,80 diff --git a/testcase/lmbench/lmbench-tune.csv b/testcase/lmbench/lmbench-tune-sched.csv similarity index 100% rename from testcase/lmbench/lmbench-tune.csv rename to testcase/lmbench/lmbench-tune-sched.csv diff --git a/testcase/lmbench/lmbench.py b/testcase/lmbench/lmbench.py index b89f5df20036b456bbbc4a05887298d60a437cc9..dba6af56043746fd702c0bbada03758173186625 100644 --- a/testcase/lmbench/lmbench.py +++ b/testcase/lmbench/lmbench.py @@ -1,17 +1,25 @@ #!/usr/bin/python3 # coding: utf-8 -# Desc: lmbench lat_ctx 工具类，供 parse-csv2case.py 通用框架调用 +# Desc: lmbench 工具类，供 parse-csv2case.py 通用框架调用 # -# 内部委托给 lib.ts_common.PerfLMbench，确保生成的 case -# 与老 case (tperf-lmbench-lat_ctx-*.py) 行为完全一致。 +# 内部委托给 lib.ts_common.PerfLMbench，支持两种参数模式： # -# CSV 参数列名与 __init__ 参数名的对应关系： -# subtest → subtest (lat_ctx) -# -P= → parallelism -# -s= → size_kb -# num_procs → num_procs +# 模式1（调度类 - lmbench-args-sched.csv）： +# subtest, parallelism, size_kb, num_procs +# +# 模式2（内存类 - lmbench-args-mm.csv）： +# benchmark_name, P, size, stride, mode, filepath, extra, setup +# 所有参数均在 CSV 中配置，修改参数只需编辑 CSV 文件 +# +# CSV 编码约定（避免文件名中出现斜杠/空格）： +# filepath: tmpfile → /tmp/test-FILE +# setup: dd4096m → dd if=/dev/zero of=/tmp/test-FILE bs=1M count=4096 oflag=direct +# dd128m → dd if=/dev/zero of=/tmp/test-FILE bs=1M count=128 oflag=direct +# extra: t → -t（传给 general_opt） +# conflict → conflict（直接追加到 general_opt） import os +import shutil import sys _suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") @@ -22,35 +30,169 @@ while _suite_top_dir != "/": sys.path.append(_suite_top_dir) from common.lib.benchmark import TSTPerf # noqa: E402 +from common.lib.common import command # noqa: E402 from lib.ts_common import PerfLMbench # noqa: E402 +# filepath 编码 → 实际路径 +_FILEPATH_MAP = { + "tmpfile": "/tmp/test-FILE", +} + +# setup 编码 → 实际命令 +_SETUP_MAP = { + "dd4096m": "/usr/bin/dd if=/dev/zero of=/tmp/test-FILE bs=1M count=4096 oflag=direct", + "dd128m": "/usr/bin/dd if=/dev/zero of=/tmp/test-FILE bs=1M count=128 oflag=direct", +} + + +def _build_general_opt(P, size, stride, mode, filepath, extra): + """根据 CSV 参数动态拼接 general_opt + + 拼接规则与老 case 完全一致： + bw_mem: -P {P} {size} {mode} [extra] + bw_pipe: -P {P} + lat_mmap: -P {P} {size} {filepath} + lat_pagefault: -P {P} {filepath} + lat_mem_rd: -P {P} [-t] {stride} {size} + lat_proc: -P {P} {mode} + """ + parts = [f"-P {P}"] + + # extra 展开：t → -t，其他原样 + extra_str = extra.strip() + if extra_str == "t": + parts.append("-t") + + # stride（如 2000，用于 lat_mem_rd，命令格式中 stride 在 size 之前） + if stride.strip(): + parts.append(stride.strip()) + + # size（如 4096m、256、2048m） + if size.strip(): + parts.append(size.strip()) + + # mode（如 fwr、cp、fcp、frd、bzero、bcopy、fork、exec、shell） + if mode.strip(): + parts.append(mode.strip()) + + # filepath 展开 + fp = filepath.strip() + if fp: + real_path = _FILEPATH_MAP.get(fp, fp) + parts.append(real_path) + + # conflict 等额外标志（非 t 类型的 extra） + if extra_str and extra_str != "t": + parts.append(extra_str) + + return " ".join(parts) + + +def _resolve_name(benchmark_name): + """从 benchmark_name 推导 PerfLMbench 的 name 参数 + + bw_mem-fwr → bw_mem + bw_mem-cp → bw_mem + lat_mem_rd-* → lat_mem_rd + lat_proc-fork → lat_proc + bw_pipe → bw_pipe + lat_mmap → lat_mmap + lat_pagefault → lat_pagefault + """ + # 已知的基准工具名列表（按长度降序匹配最长前缀） + known_names = [ + "bw_mem", "bw_pipe", + "lat_mem_rd", "lat_mmap", "lat_pagefault", "lat_proc", + ] + for name in sorted(known_names, key=len, reverse=True): + if benchmark_name == name or benchmark_name.startswith(name + "-"): + return name + # 未匹配时直接返回 benchmark_name + return benchmark_name + class PerfLmbench(TSTPerf): - """lmbench lat_ctx 工具类 — 委托给 PerfLMbench + """lmbench 工具类 — 委托给 PerfLMbench - 接收 parse-csv2case.py 传入的 CSV 字符串参数， - 拼接为 general_opt 后委托给 PerfLMbench。 + 支持调度类（lat_ctx）和内存类（bw_mem/lat_mem_rd/lat_mmap 等）。 """ def __init__( self, tc_name: str, - subtest: str = "lat_ctx", - parallelism: str = "1", - size_kb: str = "8", - num_procs: str = "12", + # 调度类参数 + subtest: str = "", + parallelism: str = "", + size_kb: str = "", + num_procs: str = "", + # 内存类参数 + benchmark_name: str = "", + P: str = "", + size: str = "", + stride: str = "", + mode: str = "", + filepath: str = "", + extra: str = "", + setup: str = "", ): super().__init__() - general_opt = f"-P {parallelism} -s {size_kb} {num_procs}" - self._impl = PerfLMbench( - name=subtest, - testname=tc_name, - label="L0:sched", - general_opt=general_opt, - ) + self._setup_cmd = "" + self._numactl = False + self._copy_hello = False + + if benchmark_name: + # 内存类模式：从 CSV 参数动态拼接 + name = _resolve_name(benchmark_name) + general_opt = _build_general_opt(P, size, stride, mode, filepath, extra) + + # setup 展开 + setup_key = setup.strip() + if setup_key: + self._setup_cmd = _SETUP_MAP.get(setup_key, setup_key) + + # lat_mem_rd 需要 numactl + if name == "lat_mem_rd": + self._numactl = True + + # lat_proc-shell 需要复制 hello + if benchmark_name == "lat_proc-shell": + self._copy_hello = True + + # bw_pipe 老 case label 是 L0:net + label = "L0:net" if name == "bw_pipe" else "L0:内存" + + self._impl = PerfLMbench( + name=name, + testname=tc_name, + label=label, + general_opt=general_opt, + ) + else: + # 调度类模式：拼接参数 + general_opt = f"-P {parallelism} -s {size_kb} {num_procs}" + self._impl = PerfLMbench( + name=subtest or "lat_ctx", + testname=tc_name, + label="L0:sched", + general_opt=general_opt, + ) def prepare(self): - return self._impl.prepare() + ret = self._impl.prepare() + # 执行 setup 命令（如 dd 创建测试文件） + if self._setup_cmd: + command(cmd=self._setup_cmd) + # lat_proc-shell 需要复制 hello + if self._copy_hello: + tperf_top_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + hello = os.path.join(tperf_top_dir, "tools/lmbench.install/build/bin/hello") + if os.path.isfile(hello): + shutil.copy(hello, "/tmp/") + # lat_mem_rd 需要 numactl 前缀 + if self._numactl: + self._impl.command = \ + f"numactl --cpunodebind=0 --membind=0 {self._impl.command}" + return ret def benchmark(self): return self._impl.benchmark() diff --git a/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-bcopy-ex-fi-mobcopy-se-si4096m-st.py b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-bcopy-ex-fi-mobcopy-se-si4096m-st.py new file mode 100755 index 0000000000000000000000000000000000000000..599554d0e32e51aada16663cc827718beb4c33a6 --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-bcopy-ex-fi-mobcopy-se-si4096m-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 51160311ddb5d02b + @用例名称: tperf-lmbench-P1-bnbw_mem-bcopy-ex-fi-mobcopy-se-si4096m-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=bw_mem-bcopy,P=1,size=4096m,stride=,mode=bcopy,filepath=,extra=,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="bw_mem-bcopy", + P="1", + size="4096m", + stride="", + mode="bcopy", + filepath="", + extra="", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=bw_mem-bcopy,P=1,size=4096m,stride=,mode=bcopy,filepath=,extra=,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-bzero-ex-fi-mobzero-se-si4096m-st.py b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-bzero-ex-fi-mobzero-se-si4096m-st.py new file mode 100755 index 0000000000000000000000000000000000000000..5f32685ec60e6da227016e1fbc85c900eebbf8dd --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-bzero-ex-fi-mobzero-se-si4096m-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 26375901b8df7d0f + @用例名称: tperf-lmbench-P1-bnbw_mem-bzero-ex-fi-mobzero-se-si4096m-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=bw_mem-bzero,P=1,size=4096m,stride=,mode=bzero,filepath=,extra=,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="bw_mem-bzero", + P="1", + size="4096m", + stride="", + mode="bzero", + filepath="", + extra="", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=bw_mem-bzero,P=1,size=4096m,stride=,mode=bzero,filepath=,extra=,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-cp-ex-fi-mocp-se-si4096m-st.py b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-cp-ex-fi-mocp-se-si4096m-st.py new file mode 100755 index 0000000000000000000000000000000000000000..009ef60b8001f7c458bcce5076b5a146024063a7 --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-cp-ex-fi-mocp-se-si4096m-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 8267572049d9f3cf + @用例名称: tperf-lmbench-P1-bnbw_mem-cp-ex-fi-mocp-se-si4096m-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=bw_mem-cp,P=1,size=4096m,stride=,mode=cp,filepath=,extra=,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="bw_mem-cp", + P="1", + size="4096m", + stride="", + mode="cp", + filepath="", + extra="", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=bw_mem-cp,P=1,size=4096m,stride=,mode=cp,filepath=,extra=,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-fcp-ex-fi-mofcp-se-si4096m-st.py b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-fcp-ex-fi-mofcp-se-si4096m-st.py new file mode 100755 index 0000000000000000000000000000000000000000..5ce0e2d9e76bd62d6563fd2f96182a4c7adb0539 --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-fcp-ex-fi-mofcp-se-si4096m-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 8134ed898240108b + @用例名称: tperf-lmbench-P1-bnbw_mem-fcp-ex-fi-mofcp-se-si4096m-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=bw_mem-fcp,P=1,size=4096m,stride=,mode=fcp,filepath=,extra=,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="bw_mem-fcp", + P="1", + size="4096m", + stride="", + mode="fcp", + filepath="", + extra="", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=bw_mem-fcp,P=1,size=4096m,stride=,mode=fcp,filepath=,extra=,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-fwr-ex-fi-mofwr-se-si4096m-st.py b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-fwr-ex-fi-mofwr-se-si4096m-st.py new file mode 100755 index 0000000000000000000000000000000000000000..e88b87485cf6c462b06ddc2979cd98db567c130b --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-fwr-ex-fi-mofwr-se-si4096m-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: bf42eb5ad9b1e089 + @用例名称: tperf-lmbench-P1-bnbw_mem-fwr-ex-fi-mofwr-se-si4096m-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=bw_mem-fwr,P=1,size=4096m,stride=,mode=fwr,filepath=,extra=,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="bw_mem-fwr", + P="1", + size="4096m", + stride="", + mode="fwr", + filepath="", + extra="", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=bw_mem-fwr,P=1,size=4096m,stride=,mode=fwr,filepath=,extra=,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-libc-bcopy-aligned-exconflict-fi-mobcopy-se-si2048m-st.py b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-libc-bcopy-aligned-exconflict-fi-mobcopy-se-si2048m-st.py new file mode 100755 index 0000000000000000000000000000000000000000..9def25eef552b4e1d3dad8fcb795f57ae9dbd6c2 --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-libc-bcopy-aligned-exconflict-fi-mobcopy-se-si2048m-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 6c8be30c69228070 + @用例名称: tperf-lmbench-P1-bnbw_mem-libc-bcopy-aligned-exconflict-fi-mobcopy-se-si2048m-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=bw_mem-libc-bcopy-aligned,P=1,size=2048m,stride=,mode=bcopy,filepath=,extra=conflict,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="bw_mem-libc-bcopy-aligned", + P="1", + size="2048m", + stride="", + mode="bcopy", + filepath="", + extra="conflict", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=bw_mem-libc-bcopy-aligned,P=1,size=2048m,stride=,mode=bcopy,filepath=,extra=conflict,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-libc-bcopy-unaligned-ex-fi-mobcopy-se-si2048m-st.py b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-libc-bcopy-unaligned-ex-fi-mobcopy-se-si2048m-st.py new file mode 100755 index 0000000000000000000000000000000000000000..df4fdd18d50ce546e86e7bfd647c871af9952286 --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-libc-bcopy-unaligned-ex-fi-mobcopy-se-si2048m-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 68dfdd2dd1ee8504 + @用例名称: tperf-lmbench-P1-bnbw_mem-libc-bcopy-unaligned-ex-fi-mobcopy-se-si2048m-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=bw_mem-libc-bcopy-unaligned,P=1,size=2048m,stride=,mode=bcopy,filepath=,extra=,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="bw_mem-libc-bcopy-unaligned", + P="1", + size="2048m", + stride="", + mode="bcopy", + filepath="", + extra="", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=bw_mem-libc-bcopy-unaligned,P=1,size=2048m,stride=,mode=bcopy,filepath=,extra=,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-read-ex-fi-mofrd-se-si4096m-st.py b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-read-ex-fi-mofrd-se-si4096m-st.py new file mode 100755 index 0000000000000000000000000000000000000000..e301c528fff0cdf26387e2cb2a7efcfcfa751751 --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-read-ex-fi-mofrd-se-si4096m-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 03e4a79ff834027d + @用例名称: tperf-lmbench-P1-bnbw_mem-read-ex-fi-mofrd-se-si4096m-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=bw_mem-read,P=1,size=4096m,stride=,mode=frd,filepath=,extra=,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="bw_mem-read", + P="1", + size="4096m", + stride="", + mode="frd", + filepath="", + extra="", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=bw_mem-read,P=1,size=4096m,stride=,mode=frd,filepath=,extra=,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-unrolled-bcopy-unaligned-ex-fi-mofcp-se-si2048m-st.py b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-unrolled-bcopy-unaligned-ex-fi-mofcp-se-si2048m-st.py new file mode 100755 index 0000000000000000000000000000000000000000..1ef1ab92c82ab63854cea35f8059d931825207fb --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-unrolled-bcopy-unaligned-ex-fi-mofcp-se-si2048m-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 7963905a2de1ff10 + @用例名称: tperf-lmbench-P1-bnbw_mem-unrolled-bcopy-unaligned-ex-fi-mofcp-se-si2048m-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=bw_mem-unrolled-bcopy-unaligned,P=1,size=2048m,stride=,mode=fcp,filepath=,extra=,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="bw_mem-unrolled-bcopy-unaligned", + P="1", + size="2048m", + stride="", + mode="fcp", + filepath="", + extra="", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=bw_mem-unrolled-bcopy-unaligned,P=1,size=2048m,stride=,mode=fcp,filepath=,extra=,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-unrolled-partial-bcopy-unaligned-ex-fi-mocp-se-si2048m-st.py b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-unrolled-partial-bcopy-unaligned-ex-fi-mocp-se-si2048m-st.py new file mode 100755 index 0000000000000000000000000000000000000000..eaa76a43aee91789b926a249d33874262b4ed0d4 --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-unrolled-partial-bcopy-unaligned-ex-fi-mocp-se-si2048m-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 9741978ccbf2172b + @用例名称: tperf-lmbench-P1-bnbw_mem-unrolled-partial-bcopy-unaligned-ex-fi-mocp-se-si2048m-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=bw_mem-unrolled-partial-bcopy-unaligned,P=1,size=2048m,stride=,mode=cp,filepath=,extra=,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="bw_mem-unrolled-partial-bcopy-unaligned", + P="1", + size="2048m", + stride="", + mode="cp", + filepath="", + extra="", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=bw_mem-unrolled-partial-bcopy-unaligned,P=1,size=2048m,stride=,mode=cp,filepath=,extra=,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-write-ex-fi-mofwr-se-si4096m-st.py b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-write-ex-fi-mofwr-se-si4096m-st.py new file mode 100755 index 0000000000000000000000000000000000000000..d34a7c059f0c62d7fdf9515fe7a6e72be4012390 --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnbw_mem-write-ex-fi-mofwr-se-si4096m-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 29a71942bf41509c + @用例名称: tperf-lmbench-P1-bnbw_mem-write-ex-fi-mofwr-se-si4096m-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=bw_mem-write,P=1,size=4096m,stride=,mode=fwr,filepath=,extra=,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="bw_mem-write", + P="1", + size="4096m", + stride="", + mode="fwr", + filepath="", + extra="", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=bw_mem-write,P=1,size=4096m,stride=,mode=fwr,filepath=,extra=,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnbw_pipe-ex-fi-mo-se-si-st.py b/testcase/lmbench/tperf-lmbench-P1-bnbw_pipe-ex-fi-mo-se-si-st.py new file mode 100755 index 0000000000000000000000000000000000000000..3a7b8cd71e6bce16dfa81e29a83c173e740c7821 --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnbw_pipe-ex-fi-mo-se-si-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 04c3015c63ba2492 + @用例名称: tperf-lmbench-P1-bnbw_pipe-ex-fi-mo-se-si-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=bw_pipe,P=1,size=,stride=,mode=,filepath=,extra=,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="bw_pipe", + P="1", + size="", + stride="", + mode="", + filepath="", + extra="", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=bw_pipe,P=1,size=,stride=,mode=,filepath=,extra=,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnlat_mem_rd-prefetch-off-ext-fi-mo-se-si256-st2000.py b/testcase/lmbench/tperf-lmbench-P1-bnlat_mem_rd-prefetch-off-ext-fi-mo-se-si256-st2000.py new file mode 100755 index 0000000000000000000000000000000000000000..5b9558122e47d28cbe79ff0804fa8b2bcb5830bc --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnlat_mem_rd-prefetch-off-ext-fi-mo-se-si256-st2000.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 56daf87fd7d13248 + @用例名称: tperf-lmbench-P1-bnlat_mem_rd-prefetch-off-ext-fi-mo-se-si256-st2000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=lat_mem_rd-prefetch-off,P=1,size=256,stride=2000,mode=,filepath=,extra=t,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="lat_mem_rd-prefetch-off", + P="1", + size="256", + stride="2000", + mode="", + filepath="", + extra="t", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=lat_mem_rd-prefetch-off,P=1,size=256,stride=2000,mode=,filepath=,extra=t,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnlat_mem_rd-prefetch-on-ex-fi-mo-se-si256-st2000.py b/testcase/lmbench/tperf-lmbench-P1-bnlat_mem_rd-prefetch-on-ex-fi-mo-se-si256-st2000.py new file mode 100755 index 0000000000000000000000000000000000000000..ceed1088e96e2e88f45ce655beed7cb7efd4d98c --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnlat_mem_rd-prefetch-on-ex-fi-mo-se-si256-st2000.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: abbdcdce2cc43a0c + @用例名称: tperf-lmbench-P1-bnlat_mem_rd-prefetch-on-ex-fi-mo-se-si256-st2000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=lat_mem_rd-prefetch-on,P=1,size=256,stride=2000,mode=,filepath=,extra=,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="lat_mem_rd-prefetch-on", + P="1", + size="256", + stride="2000", + mode="", + filepath="", + extra="", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=lat_mem_rd-prefetch-on,P=1,size=256,stride=2000,mode=,filepath=,extra=,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnlat_mmap-ex-fitmpfile-mo-sedd4096m-si4096m-st.py b/testcase/lmbench/tperf-lmbench-P1-bnlat_mmap-ex-fitmpfile-mo-sedd4096m-si4096m-st.py new file mode 100755 index 0000000000000000000000000000000000000000..2b7feeb189af07955a3c99679479b3fdcfd0208e --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnlat_mmap-ex-fitmpfile-mo-sedd4096m-si4096m-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: ebb19cdeea9c29da + @用例名称: tperf-lmbench-P1-bnlat_mmap-ex-fitmpfile-mo-sedd4096m-si4096m-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=lat_mmap,P=1,size=4096m,stride=,mode=,filepath=tmpfile,extra=,setup=dd4096m + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="lat_mmap", + P="1", + size="4096m", + stride="", + mode="", + filepath="tmpfile", + extra="", + setup="dd4096m", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=lat_mmap,P=1,size=4096m,stride=,mode=,filepath=tmpfile,extra=,setup=dd4096m + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnlat_pagefault-ex-fitmpfile-mo-sedd128m-si-st.py b/testcase/lmbench/tperf-lmbench-P1-bnlat_pagefault-ex-fitmpfile-mo-sedd128m-si-st.py new file mode 100755 index 0000000000000000000000000000000000000000..561fccb1ee65b9d8d3f33957428adb9d0c142ddc --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnlat_pagefault-ex-fitmpfile-mo-sedd128m-si-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 9101936b4204d21a + @用例名称: tperf-lmbench-P1-bnlat_pagefault-ex-fitmpfile-mo-sedd128m-si-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=lat_pagefault,P=1,size=,stride=,mode=,filepath=tmpfile,extra=,setup=dd128m + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="lat_pagefault", + P="1", + size="", + stride="", + mode="", + filepath="tmpfile", + extra="", + setup="dd128m", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=lat_pagefault,P=1,size=,stride=,mode=,filepath=tmpfile,extra=,setup=dd128m + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnlat_proc-exec-ex-fi-moexec-se-si-st.py b/testcase/lmbench/tperf-lmbench-P1-bnlat_proc-exec-ex-fi-moexec-se-si-st.py new file mode 100755 index 0000000000000000000000000000000000000000..7fe38163454ab3694248a8c06885941a8cb73727 --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnlat_proc-exec-ex-fi-moexec-se-si-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 654ebccd350e14ef + @用例名称: tperf-lmbench-P1-bnlat_proc-exec-ex-fi-moexec-se-si-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=lat_proc-exec,P=1,size=,stride=,mode=exec,filepath=,extra=,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="lat_proc-exec", + P="1", + size="", + stride="", + mode="exec", + filepath="", + extra="", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=lat_proc-exec,P=1,size=,stride=,mode=exec,filepath=,extra=,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnlat_proc-fork-ex-fi-mofork-se-si-st.py b/testcase/lmbench/tperf-lmbench-P1-bnlat_proc-fork-ex-fi-mofork-se-si-st.py new file mode 100755 index 0000000000000000000000000000000000000000..3c72c8b2656c01c72cb70b437202821e2ee21deb --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnlat_proc-fork-ex-fi-mofork-se-si-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 0758d2c53bbb353f + @用例名称: tperf-lmbench-P1-bnlat_proc-fork-ex-fi-mofork-se-si-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=lat_proc-fork,P=1,size=,stride=,mode=fork,filepath=,extra=,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="lat_proc-fork", + P="1", + size="", + stride="", + mode="fork", + filepath="", + extra="", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=lat_proc-fork,P=1,size=,stride=,mode=fork,filepath=,extra=,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/lmbench/tperf-lmbench-P1-bnlat_proc-shell-ex-fi-moshell-se-si-st.py b/testcase/lmbench/tperf-lmbench-P1-bnlat_proc-shell-ex-fi-moshell-se-si-st.py new file mode 100755 index 0000000000000000000000000000000000000000..e669de8f1cba16fdbe0dcccfd0c734c49fcf1d58 --- /dev/null +++ b/testcase/lmbench/tperf-lmbench-P1-bnlat_proc-shell-ex-fi-moshell-se-si-st.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.lmbench.lmbench import PerfLmbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 1b5e718c8e9d60c4 + @用例名称: tperf-lmbench-P1-bnlat_proc-shell-ex-fi-moshell-se-si-st + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用lmbench测试mm性能，参数：benchmark_name=lat_proc-shell,P=1,size=,stride=,mode=shell,filepath=,extra=,setup= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具lmbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfLmbench( + tc_name=self.tc_name, + benchmark_name="lat_proc-shell", + P="1", + size="", + stride="", + mode="shell", + filepath="", + extra="", + setup="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用lmbench工具测试性能，参数：benchmark_name=lat_proc-shell,P=1,size=,stride=,mode=shell,filepath=,extra=,setup= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=100, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/mlc/mlc-args-mm.csv b/testcase/mlc/mlc-args-mm.csv new file mode 100644 index 0000000000000000000000000000000000000000..7b3bcf100984995bb655488b531e189b7fe93b25 --- /dev/null +++ b/testcase/mlc/mlc-args-mm.csv @@ -0,0 +1,6 @@ +工具名称,子系统,权重,test_mode +mlc,mm,0.010749,idle_latency +mlc,mm,0.010351,loaded_latency +mlc,mm,0.009957,bandwidth_matrix +mlc,mm,0.009169,peak_injection_bandwidth +mlc,mm,0.009059,latency_matrix diff --git a/testcase/mlc/mlc-tune-mm.csv b/testcase/mlc/mlc-tune-mm.csv new file mode 100644 index 0000000000000000000000000000000000000000..e4089266e4c89435019d851bcf0fd71245811a52 --- /dev/null +++ b/testcase/mlc/mlc-tune-mm.csv @@ -0,0 +1,7 @@ +# mlc 用例稳定性参数配置 +# 格式: 用例名称,warmup,run_loop,result_select_percent +tperf-mlc-tmidle_latency,0,1,70 +tperf-mlc-tmloaded_latency,0,1,70 +tperf-mlc-tmbandwidth_matrix,0,1,70 +tperf-mlc-tmpeak_injection_bandwidth,0,1,70 +tperf-mlc-tmlatency_matrix,0,1,70 diff --git a/testcase/mlc/mlc.py b/testcase/mlc/mlc.py new file mode 100644 index 0000000000000000000000000000000000000000..1c2c6f72f79c40f21fb557d493eb2ff4ae8826ae --- /dev/null +++ b/testcase/mlc/mlc.py @@ -0,0 +1,53 @@ +#!/usr/bin/python3 +# coding: utf-8 +# Desc: mlc 工具类，供 parse-csv2case.py 通用框架调用 +# +# 内部委托给 lib.ts_common.PerfMLC +# +# CSV 参数列名与 __init__ 参数名的对应关系： +# test_mode → test_mode (idle_latency, loaded_latency, +# bandwidth_matrix, peak_injection_bandwidth, latency_matrix) + +import os +import sys + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) + +from common.lib.benchmark import TSTPerf # noqa: E402 +from lib.ts_common import PerfMLC # noqa: E402 + + +class PerfMlc(TSTPerf): + """mlc 工具类 — 委托给 PerfMLC + + 从 CSV 参数 test_mode 驱动不同的 MLC 测试模式。 + """ + + def __init__( + self, + tc_name: str, + test_mode: str = "", + ): + super().__init__() + self._impl = PerfMLC( + name=tc_name, + test_mode=test_mode.strip(), + label="L0:内存", + ) + + def prepare(self): + return self._impl.prepare() + + def benchmark(self): + return self._impl.benchmark() + + def parse_test_data(self): + return self._impl.parse_test_data() + + def cleanup(self): + return self._impl.cleanup() diff --git a/testcase/mlc/tperf-mlc-tmbandwidth_matrix.py b/testcase/mlc/tperf-mlc-tmbandwidth_matrix.py new file mode 100755 index 0000000000000000000000000000000000000000..61750ad472f6366dc2f065eb585a01c6bff44260 --- /dev/null +++ b/testcase/mlc/tperf-mlc-tmbandwidth_matrix.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.mlc.mlc import PerfMlc # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 210c294707820b62 + @用例名称: tperf-mlc-tmbandwidth_matrix + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用mlc测试mm性能，参数：test_mode=bandwidth_matrix + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具mlc运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfMlc( + tc_name=self.tc_name, + test_mode="bandwidth_matrix", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用mlc工具测试性能，参数：test_mode=bandwidth_matrix + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=70, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/mlc/tperf-mlc-tmidle_latency.py b/testcase/mlc/tperf-mlc-tmidle_latency.py new file mode 100755 index 0000000000000000000000000000000000000000..a7a950bef1cb8b2ecfdecd01e173fa952088a171 --- /dev/null +++ b/testcase/mlc/tperf-mlc-tmidle_latency.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.mlc.mlc import PerfMlc # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 15ebfcb4e95fd264 + @用例名称: tperf-mlc-tmidle_latency + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用mlc测试mm性能，参数：test_mode=idle_latency + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具mlc运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfMlc( + tc_name=self.tc_name, + test_mode="idle_latency", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用mlc工具测试性能，参数：test_mode=idle_latency + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=70, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/mlc/tperf-mlc-tmlatency_matrix.py b/testcase/mlc/tperf-mlc-tmlatency_matrix.py new file mode 100755 index 0000000000000000000000000000000000000000..a7ad9af791a502e3bc13d08d7ba207da4804606d --- /dev/null +++ b/testcase/mlc/tperf-mlc-tmlatency_matrix.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.mlc.mlc import PerfMlc # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: d0244624c559c02a + @用例名称: tperf-mlc-tmlatency_matrix + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用mlc测试mm性能，参数：test_mode=latency_matrix + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具mlc运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfMlc( + tc_name=self.tc_name, + test_mode="latency_matrix", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用mlc工具测试性能，参数：test_mode=latency_matrix + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=70, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/mlc/tperf-mlc-tmloaded_latency.py b/testcase/mlc/tperf-mlc-tmloaded_latency.py new file mode 100755 index 0000000000000000000000000000000000000000..1b977be53b2e227092e331031f9ce6075236795b --- /dev/null +++ b/testcase/mlc/tperf-mlc-tmloaded_latency.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.mlc.mlc import PerfMlc # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: f65a23061f8fb5cd + @用例名称: tperf-mlc-tmloaded_latency + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用mlc测试mm性能，参数：test_mode=loaded_latency + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具mlc运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfMlc( + tc_name=self.tc_name, + test_mode="loaded_latency", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用mlc工具测试性能，参数：test_mode=loaded_latency + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=70, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/mlc/tperf-mlc-tmpeak_injection_bandwidth.py b/testcase/mlc/tperf-mlc-tmpeak_injection_bandwidth.py new file mode 100755 index 0000000000000000000000000000000000000000..7e1eca25df457c6c0d54a34e6b722798f785a19d --- /dev/null +++ b/testcase/mlc/tperf-mlc-tmpeak_injection_bandwidth.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.mlc.mlc import PerfMlc # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: ec9c6c4298108233 + @用例名称: tperf-mlc-tmpeak_injection_bandwidth + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用mlc测试mm性能，参数：test_mode=peak_injection_bandwidth + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具mlc运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfMlc( + tc_name=self.tc_name, + test_mode="peak_injection_bandwidth", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用mlc工具测试性能，参数：test_mode=peak_injection_bandwidth + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=1, + result_select_percent=70, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/stream/stream-args-mm.csv b/testcase/stream/stream-args-mm.csv new file mode 100644 index 0000000000000000000000000000000000000000..0dfa6181b7fe96ef7099d8e3c4e817317c3481eb --- /dev/null +++ b/testcase/stream/stream-args-mm.csv @@ -0,0 +1,7 @@ +工具名称,子系统,权重,benchmark_name,OMP_NUM_THREADS +stream,memory,0.010513,single,1 +stream,memory,0.010109,thread-8,8 +stream,memory,0.009877,max,max +stream,memory,0.009769,thread-16,16 +stream,memory,0.009630,thread-4,4 +stream,memory,0.009617,thread-32,32 diff --git a/testcase/stream/stream-tune-mm.csv b/testcase/stream/stream-tune-mm.csv new file mode 100644 index 0000000000000000000000000000000000000000..dfb8f26fb043eddbfdbd6c4289cc8227e3842c88 --- /dev/null +++ b/testcase/stream/stream-tune-mm.csv @@ -0,0 +1,8 @@ +# stream 用例稳定性参数配置 +# 格式: 用例名称,warmup,run_loop,result_select_percent +tperf-stream-ON1-bnsingle,0,40,70 +tperf-stream-ON8-bnthread-8,0,40,70 +tperf-stream-ONmax-bnmax,0,40,70 +tperf-stream-ON16-bnthread-16,0,40,70 +tperf-stream-ON4-bnthread-4,0,40,70 +tperf-stream-ON32-bnthread-32,0,40,70 diff --git a/testcase/stream/stream.py b/testcase/stream/stream.py new file mode 100644 index 0000000000000000000000000000000000000000..4cbe83a939c1ec0ca28d73f51570a442e22593aa --- /dev/null +++ b/testcase/stream/stream.py @@ -0,0 +1,62 @@ +#!/usr/bin/python3 +# coding: utf-8 +# Desc: stream 工具类，供 parse-csv2case.py 通用框架调用 +# +# 内部委托给 lib.ts_common.PerfStream，通过 OMP_NUM_THREADS 环境变量 +# 控制线程数。 +# +# CSV 参数列名与 __init__ 参数名的对应关系： +# benchmark_name → 用于构造 PerfStream.name +# OMP_NUM_THREADS → 设置环境变量（max → os.cpu_count()） + +import os +import sys + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) + +from common.lib.benchmark import TSTPerf # noqa: E402 +from lib.ts_common import PerfStream # noqa: E402 + + +class PerfStreamWrapper(TSTPerf): + """stream 工具类 — 委托给 PerfStream + + 通过 OMP_NUM_THREADS 环境变量控制 stream 的线程数。 + """ + + def __init__( + self, + tc_name: str, + benchmark_name: str = "", + OMP_NUM_THREADS: str = "1", + ): + super().__init__() + # 解析线程数 + t = OMP_NUM_THREADS.strip() + if t == "max": + t = str(os.cpu_count() or 1) + self._omp_threads = t + + self._impl = PerfStream( + name=tc_name, + label="L0:内存", + ) + + def prepare(self): + # 设置 OMP_NUM_THREADS 环境变量 + os.environ["OMP_NUM_THREADS"] = self._omp_threads + return self._impl.prepare() + + def benchmark(self): + return self._impl.benchmark() + + def parse_test_data(self): + return self._impl.parse_test_data() + + def cleanup(self): + return self._impl.cleanup() diff --git a/testcase/stream/tperf-stream-ON1-bnsingle.py b/testcase/stream/tperf-stream-ON1-bnsingle.py new file mode 100755 index 0000000000000000000000000000000000000000..3a42a02aa705adf298ffc0d541a5a9ed633f89b2 --- /dev/null +++ b/testcase/stream/tperf-stream-ON1-bnsingle.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.stream.stream import PerfStreamWrapper # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: dc2cbb79983e6a8b + @用例名称: tperf-stream-ON1-bnsingle + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用stream测试memory性能，参数：benchmark_name=single,OMP_NUM_THREADS=1 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具stream运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfStreamWrapper( + tc_name=self.tc_name, + benchmark_name="single", + OMP_NUM_THREADS="1", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用stream工具测试性能，参数：benchmark_name=single,OMP_NUM_THREADS=1 + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=40, + result_select_percent=70, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/stream/tperf-stream-ON16-bnthread-16.py b/testcase/stream/tperf-stream-ON16-bnthread-16.py new file mode 100755 index 0000000000000000000000000000000000000000..a8831bc5ffc24ad5dce147253f40579fc96bd736 --- /dev/null +++ b/testcase/stream/tperf-stream-ON16-bnthread-16.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.stream.stream import PerfStreamWrapper # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 9e5319abcb2d3c79 + @用例名称: tperf-stream-ON16-bnthread-16 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用stream测试memory性能，参数：benchmark_name=thread-16,OMP_NUM_THREADS=16 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具stream运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfStreamWrapper( + tc_name=self.tc_name, + benchmark_name="thread-16", + OMP_NUM_THREADS="16", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用stream工具测试性能，参数：benchmark_name=thread-16,OMP_NUM_THREADS=16 + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=40, + result_select_percent=70, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/stream/tperf-stream-ON32-bnthread-32.py b/testcase/stream/tperf-stream-ON32-bnthread-32.py new file mode 100755 index 0000000000000000000000000000000000000000..59764776bf5395353009c336284ad6d56aa0ae7e --- /dev/null +++ b/testcase/stream/tperf-stream-ON32-bnthread-32.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.stream.stream import PerfStreamWrapper # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 6b6201cd04ac185b + @用例名称: tperf-stream-ON32-bnthread-32 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用stream测试memory性能，参数：benchmark_name=thread-32,OMP_NUM_THREADS=32 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具stream运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfStreamWrapper( + tc_name=self.tc_name, + benchmark_name="thread-32", + OMP_NUM_THREADS="32", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用stream工具测试性能，参数：benchmark_name=thread-32,OMP_NUM_THREADS=32 + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=40, + result_select_percent=70, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/stream/tperf-stream-ON4-bnthread-4.py b/testcase/stream/tperf-stream-ON4-bnthread-4.py new file mode 100755 index 0000000000000000000000000000000000000000..8a4e914cbd57237fbdeafabc7654e2ad22ea4e23 --- /dev/null +++ b/testcase/stream/tperf-stream-ON4-bnthread-4.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.stream.stream import PerfStreamWrapper # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: d8e3c11263daf930 + @用例名称: tperf-stream-ON4-bnthread-4 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用stream测试memory性能，参数：benchmark_name=thread-4,OMP_NUM_THREADS=4 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具stream运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfStreamWrapper( + tc_name=self.tc_name, + benchmark_name="thread-4", + OMP_NUM_THREADS="4", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用stream工具测试性能，参数：benchmark_name=thread-4,OMP_NUM_THREADS=4 + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=40, + result_select_percent=70, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/stream/tperf-stream-ON8-bnthread-8.py b/testcase/stream/tperf-stream-ON8-bnthread-8.py new file mode 100755 index 0000000000000000000000000000000000000000..d7e0a4b6c8f6ed7c7c24e7c59ec92cbb0c82ceb8 --- /dev/null +++ b/testcase/stream/tperf-stream-ON8-bnthread-8.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.stream.stream import PerfStreamWrapper # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 7c65d5f1581e218a + @用例名称: tperf-stream-ON8-bnthread-8 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用stream测试memory性能，参数：benchmark_name=thread-8,OMP_NUM_THREADS=8 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具stream运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfStreamWrapper( + tc_name=self.tc_name, + benchmark_name="thread-8", + OMP_NUM_THREADS="8", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用stream工具测试性能，参数：benchmark_name=thread-8,OMP_NUM_THREADS=8 + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=40, + result_select_percent=70, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/stream/tperf-stream-ONmax-bnmax.py b/testcase/stream/tperf-stream-ONmax-bnmax.py new file mode 100755 index 0000000000000000000000000000000000000000..c0bd89768158ddca69ccc2628e2e32a74300d824 --- /dev/null +++ b/testcase/stream/tperf-stream-ONmax-bnmax.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.stream.stream import PerfStreamWrapper # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: e2761c3eb0307ec5 + @用例名称: tperf-stream-ONmax-bnmax + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用stream测试memory性能，参数：benchmark_name=max,OMP_NUM_THREADS=max + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具stream运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfStreamWrapper( + tc_name=self.tc_name, + benchmark_name="max", + OMP_NUM_THREADS="max", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用stream工具测试性能，参数：benchmark_name=max,OMP_NUM_THREADS=max + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=0, + run_loop=40, + result_select_percent=70, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench-args-mm.csv b/testcase/sysbench/sysbench-args-mm.csv new file mode 100644 index 0000000000000000000000000000000000000000..447be1403a5c43b69c7031298cf541fbc3a60a74 --- /dev/null +++ b/testcase/sysbench/sysbench-args-mm.csv @@ -0,0 +1,20 @@ +工具名称,子系统,权重,benchmark_name,memory_block_size,memory_total_size,memory_oper,memory_access_mode,mm_threads,mm_time +sysbench,mm,0.014147,block-1k-size-1g-seqrd,1k,1G,read,seq,, +sysbench,mm,0.012446,block-32k-size-1g-seqrd,32k,1G,read,seq,, +sysbench,mm,0.010960,block-128k-size-10g-seqwr,128k,10G,write,seq,, +sysbench,mm,0.010952,block-32k-size-1g-rndrd,32k,1G,read,rnd,, +sysbench,mm,0.010836,block-256k-size-10g-rndwr,256k,10G,write,rnd,, +sysbench,mm,0.010757,thread-1,,,,,1,300 +sysbench,mm,0.010610,thread-max,,,,,max,300 +sysbench,mm,0.010454,block-512k-size-10g-seqwr,512k,10G,write,seq,, +sysbench,mm,0.010428,block-64k-size-10g-rndwr,32k,10G,write,rnd,, +sysbench,mm,0.010028,block-4k-size-1g-seqrd,4k,1G,read,seq,, +sysbench,mm,0.009988,block-512k-size-10g-rndwr,512k,10G,write,rnd,, +sysbench,mm,0.009876,block-1g-size-10g-rndwr,1G,10G,write,rnd,, +sysbench,mm,0.009619,block-1g-size-10g-rndrd,1G,10G,read,rnd,, +sysbench,mm,0.009602,block-32k-size-1g-seqwr,32k,1G,write,seq,, +sysbench,mm,0.009429,block-16k-size-1g-seqrd,16k,1G,read,seq,, +sysbench,mm,0.009398,block-128k-size-10g-rndwr,128k,10G,write,rnd,, +sysbench,mm,0.009356,block-64k-size-10g-rndrd,64k,10G,read,rnd,, +sysbench,mm,0.009053,block-2k-size-1g-seqrd,2k,1G,read,seq,, +sysbench,mm,0.008753,block-32k-size-1g-rndwr,32k,1G,write,rnd,, diff --git a/testcase/sysbench/sysbench-tune-mm.csv b/testcase/sysbench/sysbench-tune-mm.csv new file mode 100644 index 0000000000000000000000000000000000000000..b29b145912e519a86c655a71b0378a12daa3edc9 --- /dev/null +++ b/testcase/sysbench/sysbench-tune-mm.csv @@ -0,0 +1,21 @@ +# sysbench memory 用例稳定性参数配置 +# 格式: 用例名称,warmup,run_loop,result_select_percent +tperf-sysbench-bnblock-1k-size-1g-seqrd-maseq-mb1k-moread-mt1G-mt-mt,1,1,90 +tperf-sysbench-bnblock-32k-size-1g-seqrd-maseq-mb32k-moread-mt1G-mt-mt,1,1,90 +tperf-sysbench-bnblock-128k-size-10g-seqwr-maseq-mb128k-mowrite-mt10G-mt-mt,1,1,90 +tperf-sysbench-bnblock-32k-size-1g-rndrd-marnd-mb32k-moread-mt1G-mt-mt,1,1,90 +tperf-sysbench-bnblock-256k-size-10g-rndwr-marnd-mb256k-mowrite-mt10G-mt-mt,1,1,90 +tperf-sysbench-bnthread-1-ma-mb-mo-mt-mt1-mt300,1,1,90 +tperf-sysbench-bnthread-max-ma-mb-mo-mt-mtmax-mt300,1,1,90 +tperf-sysbench-bnblock-512k-size-10g-seqwr-maseq-mb512k-mowrite-mt10G-mt-mt,1,1,90 +tperf-sysbench-bnblock-64k-size-10g-rndwr-marnd-mb32k-mowrite-mt10G-mt-mt,1,1,90 +tperf-sysbench-bnblock-4k-size-1g-seqrd-maseq-mb4k-moread-mt1G-mt-mt,1,1,90 +tperf-sysbench-bnblock-512k-size-10g-rndwr-marnd-mb512k-mowrite-mt10G-mt-mt,1,1,90 +tperf-sysbench-bnblock-1g-size-10g-rndwr-marnd-mb1G-mowrite-mt10G-mt-mt,1,1,90 +tperf-sysbench-bnblock-1g-size-10g-rndrd-marnd-mb1G-moread-mt10G-mt-mt,1,1,90 +tperf-sysbench-bnblock-32k-size-1g-seqwr-maseq-mb32k-mowrite-mt1G-mt-mt,1,1,90 +tperf-sysbench-bnblock-16k-size-1g-seqrd-maseq-mb16k-moread-mt1G-mt-mt,1,1,90 +tperf-sysbench-bnblock-128k-size-10g-rndwr-marnd-mb128k-mowrite-mt10G-mt-mt,1,1,90 +tperf-sysbench-bnblock-64k-size-10g-rndrd-marnd-mb64k-moread-mt10G-mt-mt,1,1,90 +tperf-sysbench-bnblock-2k-size-1g-seqrd-maseq-mb2k-moread-mt1G-mt-mt,1,1,90 +tperf-sysbench-bnblock-32k-size-1g-rndwr-marnd-mb32k-mowrite-mt1G-mt-mt,1,1,90 diff --git a/testcase/sysbench/sysbench-tune.csv b/testcase/sysbench/sysbench-tune-sched.csv similarity index 100% rename from testcase/sysbench/sysbench-tune.csv rename to testcase/sysbench/sysbench-tune-sched.csv diff --git a/testcase/sysbench/sysbench.py b/testcase/sysbench/sysbench.py index ee2fb0d21fe9848d619bbc7e2ff7cdd18396cb44..c6c734848083c28cf040c5b51461e654f31af691 100644 --- a/testcase/sysbench/sysbench.py +++ b/testcase/sysbench/sysbench.py @@ -1,14 +1,20 @@ #!/usr/bin/python3 # coding: utf-8 -# Desc: sysbench threads 工具类，供 parse-csv2case.py 通用框架调用 +# Desc: sysbench 工具类，供 parse-csv2case.py 通用框架调用 # -# 内部委托给 lib.ts_common.PerfSysBench，确保生成的 case -# 与老 case (tperf-sysbench-threads-*.py) 行为完全一致。 +# 内部委托给 lib.ts_common.PerfSysBench，支持两种参数模式： # -# CSV 参数列名与 __init__ 参数名的对应关系： -# --threads= → threads -# --thread-locks= → thread_locks -# --thread-yields= → thread_yields +# 模式1（调度类 - sysbench-args-sched.csv）： +# threads, thread_locks, thread_yields → testname="threads" +# +# 模式2（内存类 - sysbench-args-mm.csv）： +# benchmark_name, memory_block_size, memory_total_size, +# memory_oper, memory_access_mode, mm_threads, mm_time +# 所有参数均在 CSV 中配置，修改参数只需编辑 CSV 文件 +# +# CSV mm_threads 编码约定： +# max → os.cpu_count()（运行时获取最大线程数） +# 数字 → 直接使用 import os import sys @@ -24,32 +30,84 @@ from common.lib.benchmark import TSTPerf # noqa: E402 from lib.ts_common import PerfSysBench # noqa: E402 +def _build_memory_opt(memory_block_size, memory_total_size, + memory_oper, memory_access_mode, + mm_threads, mm_time): + """根据 CSV 列值动态拼接 memory 模式的 general_opt""" + parts = [] + + # block 模式参数 + if memory_block_size.strip(): + parts.append(f"--memory-block-size={memory_block_size.strip()}") + if memory_total_size.strip(): + parts.append(f"--memory-total-size={memory_total_size.strip()}") + if memory_oper.strip(): + parts.append(f"--memory-oper={memory_oper.strip()}") + if memory_access_mode.strip(): + parts.append(f"--memory-access-mode={memory_access_mode.strip()}") + + # thread 模式参数 + t = mm_threads.strip() + if t: + if t == "max": + t = str(os.cpu_count() or 1) + parts.append(f"--threads={t}") + if mm_time.strip(): + parts.append(f"--time={mm_time.strip()}") + + return " ".join(parts) + + class PerfSysbench(TSTPerf): - """sysbench threads 工具类 — 委托给 PerfSysBench + """sysbench 工具类 — 委托给 PerfSysBench - 接收 parse-csv2case.py 传入的 CSV 字符串参数， - 拼接为 general_opt 后委托给 PerfSysBench。 + 支持调度类（threads）和内存类（memory）。 """ def __init__( self, tc_name: str, - threads: str = "1", - thread_locks: str = "4", - thread_yields: str = "1000", + # 调度类参数 + threads: str = "", + thread_locks: str = "", + thread_yields: str = "", + # 内存类参数 + benchmark_name: str = "", + memory_block_size: str = "", + memory_total_size: str = "", + memory_oper: str = "", + memory_access_mode: str = "", + mm_threads: str = "", + mm_time: str = "", ): super().__init__() - general_opt = ( - f"--threads={threads} " - f"--thread-locks={thread_locks} " - f"--thread-yields={thread_yields}" - ) - self._impl = PerfSysBench( - name=tc_name, - testname="threads", - label="L0:调度", - general_opt=general_opt, - ) + + if benchmark_name: + # 内存类模式：从 CSV 参数动态拼接 + general_opt = _build_memory_opt( + memory_block_size, memory_total_size, + memory_oper, memory_access_mode, + mm_threads, mm_time, + ) + self._impl = PerfSysBench( + name=tc_name, + testname="memory", + label="L0:内存", + general_opt=general_opt, + ) + else: + # 调度类模式：拼接参数 + general_opt = ( + f"--threads={threads} " + f"--thread-locks={thread_locks} " + f"--thread-yields={thread_yields}" + ) + self._impl = PerfSysBench( + name=tc_name, + testname="threads", + label="L0:调度", + general_opt=general_opt, + ) def prepare(self): return self._impl.prepare() diff --git a/testcase/sysbench/tperf-sysbench-bnblock-128k-size-10g-rndwr-marnd-mb128k-mowrite-mt10G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-128k-size-10g-rndwr-marnd-mb128k-mowrite-mt10G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..a8c49a42d9f2d3074d7efffaaac324f7d82cd148 --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-128k-size-10g-rndwr-marnd-mb128k-mowrite-mt10G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 518505998cf24f18 + @用例名称: tperf-sysbench-bnblock-128k-size-10g-rndwr-marnd-mb128k-mowrite-mt10G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-128k-size-10g-rndwr,memory_block_size=128k,memory_total_size=10G,memory_oper=write,memory_access_mode=rnd,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-128k-size-10g-rndwr", + memory_block_size="128k", + memory_total_size="10G", + memory_oper="write", + memory_access_mode="rnd", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-128k-size-10g-rndwr,memory_block_size=128k,memory_total_size=10G,memory_oper=write,memory_access_mode=rnd,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-128k-size-10g-seqwr-maseq-mb128k-mowrite-mt10G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-128k-size-10g-seqwr-maseq-mb128k-mowrite-mt10G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..722a1e2ce6c63de477ebe0c4c49c040581467173 --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-128k-size-10g-seqwr-maseq-mb128k-mowrite-mt10G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: a29c60a53ce450c1 + @用例名称: tperf-sysbench-bnblock-128k-size-10g-seqwr-maseq-mb128k-mowrite-mt10G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-128k-size-10g-seqwr,memory_block_size=128k,memory_total_size=10G,memory_oper=write,memory_access_mode=seq,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-128k-size-10g-seqwr", + memory_block_size="128k", + memory_total_size="10G", + memory_oper="write", + memory_access_mode="seq", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-128k-size-10g-seqwr,memory_block_size=128k,memory_total_size=10G,memory_oper=write,memory_access_mode=seq,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-16k-size-1g-seqrd-maseq-mb16k-moread-mt1G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-16k-size-1g-seqrd-maseq-mb16k-moread-mt1G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..e2262b94a72d103e307ddef89eb37d3db70cb923 --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-16k-size-1g-seqrd-maseq-mb16k-moread-mt1G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 29553bd1a2fd1789 + @用例名称: tperf-sysbench-bnblock-16k-size-1g-seqrd-maseq-mb16k-moread-mt1G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-16k-size-1g-seqrd,memory_block_size=16k,memory_total_size=1G,memory_oper=read,memory_access_mode=seq,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-16k-size-1g-seqrd", + memory_block_size="16k", + memory_total_size="1G", + memory_oper="read", + memory_access_mode="seq", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-16k-size-1g-seqrd,memory_block_size=16k,memory_total_size=1G,memory_oper=read,memory_access_mode=seq,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-1g-size-10g-rndrd-marnd-mb1G-moread-mt10G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-1g-size-10g-rndrd-marnd-mb1G-moread-mt10G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..9c135f15cfab7dbf2d8afbffb3d2f50e44afd2de --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-1g-size-10g-rndrd-marnd-mb1G-moread-mt10G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: edc48c3401732aeb + @用例名称: tperf-sysbench-bnblock-1g-size-10g-rndrd-marnd-mb1G-moread-mt10G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-1g-size-10g-rndrd,memory_block_size=1G,memory_total_size=10G,memory_oper=read,memory_access_mode=rnd,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-1g-size-10g-rndrd", + memory_block_size="1G", + memory_total_size="10G", + memory_oper="read", + memory_access_mode="rnd", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-1g-size-10g-rndrd,memory_block_size=1G,memory_total_size=10G,memory_oper=read,memory_access_mode=rnd,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-1g-size-10g-rndwr-marnd-mb1G-mowrite-mt10G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-1g-size-10g-rndwr-marnd-mb1G-mowrite-mt10G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..d6351aedf9fe55eaaf3895495a89d9e1abb4acdb --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-1g-size-10g-rndwr-marnd-mb1G-mowrite-mt10G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 683da07dc64b21cf + @用例名称: tperf-sysbench-bnblock-1g-size-10g-rndwr-marnd-mb1G-mowrite-mt10G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-1g-size-10g-rndwr,memory_block_size=1G,memory_total_size=10G,memory_oper=write,memory_access_mode=rnd,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-1g-size-10g-rndwr", + memory_block_size="1G", + memory_total_size="10G", + memory_oper="write", + memory_access_mode="rnd", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-1g-size-10g-rndwr,memory_block_size=1G,memory_total_size=10G,memory_oper=write,memory_access_mode=rnd,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-1k-size-1g-seqrd-maseq-mb1k-moread-mt1G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-1k-size-1g-seqrd-maseq-mb1k-moread-mt1G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..431543e8e1814d64e3598808491627db5c925388 --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-1k-size-1g-seqrd-maseq-mb1k-moread-mt1G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 5c2c52bb7751d1ac + @用例名称: tperf-sysbench-bnblock-1k-size-1g-seqrd-maseq-mb1k-moread-mt1G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-1k-size-1g-seqrd,memory_block_size=1k,memory_total_size=1G,memory_oper=read,memory_access_mode=seq,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-1k-size-1g-seqrd", + memory_block_size="1k", + memory_total_size="1G", + memory_oper="read", + memory_access_mode="seq", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-1k-size-1g-seqrd,memory_block_size=1k,memory_total_size=1G,memory_oper=read,memory_access_mode=seq,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-256k-size-10g-rndwr-marnd-mb256k-mowrite-mt10G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-256k-size-10g-rndwr-marnd-mb256k-mowrite-mt10G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..834575dc18a6431210ea519dced3ab7659da7b61 --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-256k-size-10g-rndwr-marnd-mb256k-mowrite-mt10G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: bde0b1d513363cc2 + @用例名称: tperf-sysbench-bnblock-256k-size-10g-rndwr-marnd-mb256k-mowrite-mt10G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-256k-size-10g-rndwr,memory_block_size=256k,memory_total_size=10G,memory_oper=write,memory_access_mode=rnd,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-256k-size-10g-rndwr", + memory_block_size="256k", + memory_total_size="10G", + memory_oper="write", + memory_access_mode="rnd", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-256k-size-10g-rndwr,memory_block_size=256k,memory_total_size=10G,memory_oper=write,memory_access_mode=rnd,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-2k-size-1g-seqrd-maseq-mb2k-moread-mt1G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-2k-size-1g-seqrd-maseq-mb2k-moread-mt1G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..8da576cbdd60e4483623662c071ac026937f2389 --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-2k-size-1g-seqrd-maseq-mb2k-moread-mt1G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 2409fc154e24077a + @用例名称: tperf-sysbench-bnblock-2k-size-1g-seqrd-maseq-mb2k-moread-mt1G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-2k-size-1g-seqrd,memory_block_size=2k,memory_total_size=1G,memory_oper=read,memory_access_mode=seq,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-2k-size-1g-seqrd", + memory_block_size="2k", + memory_total_size="1G", + memory_oper="read", + memory_access_mode="seq", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-2k-size-1g-seqrd,memory_block_size=2k,memory_total_size=1G,memory_oper=read,memory_access_mode=seq,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-32k-size-1g-rndrd-marnd-mb32k-moread-mt1G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-32k-size-1g-rndrd-marnd-mb32k-moread-mt1G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..93336d787276f9c3478317b7acd957593155101b --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-32k-size-1g-rndrd-marnd-mb32k-moread-mt1G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 06928f7ae3242005 + @用例名称: tperf-sysbench-bnblock-32k-size-1g-rndrd-marnd-mb32k-moread-mt1G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-32k-size-1g-rndrd,memory_block_size=32k,memory_total_size=1G,memory_oper=read,memory_access_mode=rnd,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-32k-size-1g-rndrd", + memory_block_size="32k", + memory_total_size="1G", + memory_oper="read", + memory_access_mode="rnd", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-32k-size-1g-rndrd,memory_block_size=32k,memory_total_size=1G,memory_oper=read,memory_access_mode=rnd,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-32k-size-1g-rndwr-marnd-mb32k-mowrite-mt1G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-32k-size-1g-rndwr-marnd-mb32k-mowrite-mt1G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..b23707bb6bef073ba4bda1e987b71cbee7667404 --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-32k-size-1g-rndwr-marnd-mb32k-mowrite-mt1G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 1f4f7308cbed88b0 + @用例名称: tperf-sysbench-bnblock-32k-size-1g-rndwr-marnd-mb32k-mowrite-mt1G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-32k-size-1g-rndwr,memory_block_size=32k,memory_total_size=1G,memory_oper=write,memory_access_mode=rnd,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-32k-size-1g-rndwr", + memory_block_size="32k", + memory_total_size="1G", + memory_oper="write", + memory_access_mode="rnd", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-32k-size-1g-rndwr,memory_block_size=32k,memory_total_size=1G,memory_oper=write,memory_access_mode=rnd,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-32k-size-1g-seqrd-maseq-mb32k-moread-mt1G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-32k-size-1g-seqrd-maseq-mb32k-moread-mt1G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..27eaae5685a9c979ade92be7092988781f112fe3 --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-32k-size-1g-seqrd-maseq-mb32k-moread-mt1G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: e8ebb20ff96ee2de + @用例名称: tperf-sysbench-bnblock-32k-size-1g-seqrd-maseq-mb32k-moread-mt1G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-32k-size-1g-seqrd,memory_block_size=32k,memory_total_size=1G,memory_oper=read,memory_access_mode=seq,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-32k-size-1g-seqrd", + memory_block_size="32k", + memory_total_size="1G", + memory_oper="read", + memory_access_mode="seq", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-32k-size-1g-seqrd,memory_block_size=32k,memory_total_size=1G,memory_oper=read,memory_access_mode=seq,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-32k-size-1g-seqwr-maseq-mb32k-mowrite-mt1G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-32k-size-1g-seqwr-maseq-mb32k-mowrite-mt1G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..4c04616d210962f5e839a5d18acd774b255de27d --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-32k-size-1g-seqwr-maseq-mb32k-mowrite-mt1G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: e3784aa6424672d8 + @用例名称: tperf-sysbench-bnblock-32k-size-1g-seqwr-maseq-mb32k-mowrite-mt1G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-32k-size-1g-seqwr,memory_block_size=32k,memory_total_size=1G,memory_oper=write,memory_access_mode=seq,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-32k-size-1g-seqwr", + memory_block_size="32k", + memory_total_size="1G", + memory_oper="write", + memory_access_mode="seq", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-32k-size-1g-seqwr,memory_block_size=32k,memory_total_size=1G,memory_oper=write,memory_access_mode=seq,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-4k-size-1g-seqrd-maseq-mb4k-moread-mt1G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-4k-size-1g-seqrd-maseq-mb4k-moread-mt1G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..5b08b07b6a7ae0d52054bcaca2d30e1f5de7522f --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-4k-size-1g-seqrd-maseq-mb4k-moread-mt1G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: c37d321f84116551 + @用例名称: tperf-sysbench-bnblock-4k-size-1g-seqrd-maseq-mb4k-moread-mt1G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-4k-size-1g-seqrd,memory_block_size=4k,memory_total_size=1G,memory_oper=read,memory_access_mode=seq,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-4k-size-1g-seqrd", + memory_block_size="4k", + memory_total_size="1G", + memory_oper="read", + memory_access_mode="seq", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-4k-size-1g-seqrd,memory_block_size=4k,memory_total_size=1G,memory_oper=read,memory_access_mode=seq,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-512k-size-10g-rndwr-marnd-mb512k-mowrite-mt10G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-512k-size-10g-rndwr-marnd-mb512k-mowrite-mt10G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..d11fe8b4009e82c80832f79a929b7c03bb03b12f --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-512k-size-10g-rndwr-marnd-mb512k-mowrite-mt10G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 41bc40273062b1b9 + @用例名称: tperf-sysbench-bnblock-512k-size-10g-rndwr-marnd-mb512k-mowrite-mt10G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-512k-size-10g-rndwr,memory_block_size=512k,memory_total_size=10G,memory_oper=write,memory_access_mode=rnd,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-512k-size-10g-rndwr", + memory_block_size="512k", + memory_total_size="10G", + memory_oper="write", + memory_access_mode="rnd", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-512k-size-10g-rndwr,memory_block_size=512k,memory_total_size=10G,memory_oper=write,memory_access_mode=rnd,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-512k-size-10g-seqwr-maseq-mb512k-mowrite-mt10G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-512k-size-10g-seqwr-maseq-mb512k-mowrite-mt10G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..9b994923a6847f7bc8970621b59b2d70eed671cb --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-512k-size-10g-seqwr-maseq-mb512k-mowrite-mt10G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: de5527be1dbd0d42 + @用例名称: tperf-sysbench-bnblock-512k-size-10g-seqwr-maseq-mb512k-mowrite-mt10G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-512k-size-10g-seqwr,memory_block_size=512k,memory_total_size=10G,memory_oper=write,memory_access_mode=seq,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-512k-size-10g-seqwr", + memory_block_size="512k", + memory_total_size="10G", + memory_oper="write", + memory_access_mode="seq", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-512k-size-10g-seqwr,memory_block_size=512k,memory_total_size=10G,memory_oper=write,memory_access_mode=seq,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-64k-size-10g-rndrd-marnd-mb64k-moread-mt10G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-64k-size-10g-rndrd-marnd-mb64k-moread-mt10G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..dc021c9fb14227a70b7754bcfa21b53f7b19b897 --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-64k-size-10g-rndrd-marnd-mb64k-moread-mt10G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 064d089f031584cf + @用例名称: tperf-sysbench-bnblock-64k-size-10g-rndrd-marnd-mb64k-moread-mt10G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-64k-size-10g-rndrd,memory_block_size=64k,memory_total_size=10G,memory_oper=read,memory_access_mode=rnd,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-64k-size-10g-rndrd", + memory_block_size="64k", + memory_total_size="10G", + memory_oper="read", + memory_access_mode="rnd", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-64k-size-10g-rndrd,memory_block_size=64k,memory_total_size=10G,memory_oper=read,memory_access_mode=rnd,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnblock-64k-size-10g-rndwr-marnd-mb32k-mowrite-mt10G-mt-mt.py b/testcase/sysbench/tperf-sysbench-bnblock-64k-size-10g-rndwr-marnd-mb32k-mowrite-mt10G-mt-mt.py new file mode 100755 index 0000000000000000000000000000000000000000..012e0f53e4278ab147f8444abd33f2601487ef58 --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnblock-64k-size-10g-rndwr-marnd-mb32k-mowrite-mt10G-mt-mt.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 87402264bee88610 + @用例名称: tperf-sysbench-bnblock-64k-size-10g-rndwr-marnd-mb32k-mowrite-mt10G-mt-mt + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=block-64k-size-10g-rndwr,memory_block_size=32k,memory_total_size=10G,memory_oper=write,memory_access_mode=rnd,mm_threads=,mm_time= + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="block-64k-size-10g-rndwr", + memory_block_size="32k", + memory_total_size="10G", + memory_oper="write", + memory_access_mode="rnd", + mm_threads="", + mm_time="", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=block-64k-size-10g-rndwr,memory_block_size=32k,memory_total_size=10G,memory_oper=write,memory_access_mode=rnd,mm_threads=,mm_time= + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnthread-1-ma-mb-mo-mt-mt1-mt300.py b/testcase/sysbench/tperf-sysbench-bnthread-1-ma-mb-mo-mt-mt1-mt300.py new file mode 100755 index 0000000000000000000000000000000000000000..add4dc5521722a13d2d812028f7dee9c5983d115 --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnthread-1-ma-mb-mo-mt-mt1-mt300.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 8d3e95c35af84f44 + @用例名称: tperf-sysbench-bnthread-1-ma-mb-mo-mt-mt1-mt300 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=thread-1,memory_block_size=,memory_total_size=,memory_oper=,memory_access_mode=,mm_threads=1,mm_time=300 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="thread-1", + memory_block_size="", + memory_total_size="", + memory_oper="", + memory_access_mode="", + mm_threads="1", + mm_time="300", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=thread-1,memory_block_size=,memory_total_size=,memory_oper=,memory_access_mode=,mm_threads=1,mm_time=300 + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/tperf-sysbench-bnthread-max-ma-mb-mo-mt-mtmax-mt300.py b/testcase/sysbench/tperf-sysbench-bnthread-max-ma-mb-mo-mt-mtmax-mt300.py new file mode 100755 index 0000000000000000000000000000000000000000..69d5951857e4eaa4f19bc405bd2abcd02b3dc3e5 --- /dev/null +++ b/testcase/sysbench/tperf-sysbench-bnthread-max-ma-mb-mo-mt-mtmax-mt300.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 0111950f4a5dda8d + @用例名称: tperf-sysbench-bnthread-max-ma-mb-mo-mt-mtmax-mt300 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mm性能，参数：benchmark_name=thread-max,memory_block_size=,memory_total_size=,memory_oper=,memory_access_mode=,mm_threads=max,mm_time=300 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + benchmark_name="thread-max", + memory_block_size="", + memory_total_size="", + memory_oper="", + memory_access_mode="", + mm_threads="max", + mm_time="300", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试性能，参数：benchmark_name=thread-max,memory_block_size=,memory_total_size=,memory_oper=,memory_access_mode=,mm_threads=max,mm_time=300 + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=1, + result_select_percent=90, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/unixbench/tperf-unixbench-c1-teshell16.py b/testcase/unixbench/tperf-unixbench-c1-teshell16.py new file mode 100755 index 0000000000000000000000000000000000000000..8a2b73b92ef4d633512771b38389baeb1530586e --- /dev/null +++ b/testcase/unixbench/tperf-unixbench-c1-teshell16.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.unixbench.unixbench import PerfUnixBench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 1cc91a723ab2f77d + @用例名称: tperf-unixbench-c1-teshell16 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用unixbench测试mm性能，参数：testname=shell16,c=1 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具unixbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfUnixBench( + tc_name=self.tc_name, + testname="shell16", + c="1", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用unixbench工具测试性能，参数：testname=shell16,c=1 + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=10, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/unixbench/tperf-unixbench-c1-tespawn.py b/testcase/unixbench/tperf-unixbench-c1-tespawn.py new file mode 100755 index 0000000000000000000000000000000000000000..2ba79303301a893136bead0f2fd02776eaf4da7e --- /dev/null +++ b/testcase/unixbench/tperf-unixbench-c1-tespawn.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +# coding: utf-8 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.unixbench.unixbench import PerfUnixBench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 413c9690cce3946f + @用例名称: tperf-unixbench-c1-tespawn + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: + @自动化: 1 + @超时时间: 0 + @用例描述: 使用unixbench测试mm性能，参数：testname=spawn,c=1 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具unixbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + self.perf_tool = PerfUnixBench( + tc_name=self.tc_name, + testname="spawn", + c="1", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用unixbench工具测试性能，参数：testname=spawn,c=1 + # @预期结果: 测试正常,性能数据采集正常 + self.perf_tool.run( + warmup=1, + run_loop=10, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/unixbench/unixbench-args-mm.csv b/testcase/unixbench/unixbench-args-mm.csv new file mode 100644 index 0000000000000000000000000000000000000000..0747c3ebaad097e2fb5a7e6e3573d4d89238c38d --- /dev/null +++ b/testcase/unixbench/unixbench-args-mm.csv @@ -0,0 +1,3 @@ +工具名称,子系统,权重,testname,c +unixbench,mm,0.010967,spawn,1 +unixbench,mm,0.010685,shell16,1 diff --git a/testcase/unixbench/unixbench-tune-mm.csv b/testcase/unixbench/unixbench-tune-mm.csv new file mode 100644 index 0000000000000000000000000000000000000000..7e89ca713834299ef6c4c75eeb8ca8837dd2754d --- /dev/null +++ b/testcase/unixbench/unixbench-tune-mm.csv @@ -0,0 +1,4 @@ +# unixbench 用例稳定性参数配置 +# 格式: 用例名称,warmup,run_loop,result_select_percent +tperf-unixbench-c1-tespawn,1,10,80 +tperf-unixbench-c1-teshell16,1,10,80 diff --git a/testcase/unixbench/unixbench.py b/testcase/unixbench/unixbench.py new file mode 100644 index 0000000000000000000000000000000000000000..09c6200b731f4b133bae68a4e5ffdae6237cc17c --- /dev/null +++ b/testcase/unixbench/unixbench.py @@ -0,0 +1,58 @@ +#!/usr/bin/python3 +# coding: utf-8 +# Desc: unixbench 工具类，供 parse-csv2case.py 通用框架调用 +# +# 内部委托给 lib.ts_common.PerfUnixbench +# +# CSV 参数列名与 __init__ 参数名的对应关系： +# testname → testname (spawn, shell16, ...) +# c → -c 参数值（并发数） +# +# general_opt 拼接规则: "-c {c} {testname}" + +import os +import sys + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) + +from common.lib.benchmark import TSTPerf # noqa: E402 +from lib.ts_common import PerfUnixbench # noqa: E402 + + +class PerfUnixBench(TSTPerf): + """unixbench 工具类 — 委托给 PerfUnixbench + + 从 CSV 参数动态拼接 general_opt。 + """ + + def __init__( + self, + tc_name: str, + testname: str = "", + c: str = "1", + ): + super().__init__() + general_opt = f"-c {c.strip()} {testname.strip()}" + self._impl = PerfUnixbench( + name=tc_name, + testname=f"unixbench-{testname.strip()}", + label="L0:内存", + general_opt=general_opt, + ) + + def prepare(self): + return self._impl.prepare() + + def benchmark(self): + return self._impl.benchmark() + + def parse_test_data(self): + return self._impl.parse_test_data() + + def cleanup(self): + return self._impl.cleanup()