|
| 1 | +import json |
| 2 | +import pathlib |
| 3 | +from typing import Any |
| 4 | + |
| 5 | +from hwbench.bench.benchmark import ExternalBench |
| 6 | +from hwbench.bench.engine import EngineBase, EngineModuleBase |
| 7 | +from hwbench.bench.parameters import BenchmarkParameters |
| 8 | +from hwbench.utils.helpers import fatal |
| 9 | + |
| 10 | + |
| 11 | +class EngineModuleCmdline(EngineModuleBase): |
| 12 | + """This class implements the EngineModuleBase for fio""" |
| 13 | + |
| 14 | + def __init__(self, engine: EngineBase, engine_module_name: str, fake_stdout=None): |
| 15 | + super().__init__(engine, engine_module_name) |
| 16 | + self.engine_module_name = engine_module_name |
| 17 | + self.load_module_parameter(fake_stdout) |
| 18 | + |
| 19 | + def load_module_parameter(self, fake_stdout=None): |
| 20 | + # if needed add module parameters to your module |
| 21 | + self.add_module_parameter("cmdline") |
| 22 | + |
| 23 | + def validate_module_parameters(self, p: BenchmarkParameters): |
| 24 | + msg = super().validate_module_parameters(p) |
| 25 | + FioCmdLine(self, p).parse_parameters() |
| 26 | + return msg |
| 27 | + |
| 28 | + def run_cmd(self, p: BenchmarkParameters): |
| 29 | + return FioCmdLine(self, p).run_cmd() |
| 30 | + |
| 31 | + def run(self, p: BenchmarkParameters): |
| 32 | + return FioCmdLine(self, p).run() |
| 33 | + |
| 34 | + def fully_skipped_job(self, p) -> bool: |
| 35 | + return FioCmdLine(self, p).fully_skipped_job() |
| 36 | + |
| 37 | + |
| 38 | +class Engine(EngineBase): |
| 39 | + """The main fio class.""" |
| 40 | + |
| 41 | + def __init__(self, fake_stdout=None): |
| 42 | + super().__init__("fio", "fio") |
| 43 | + self.add_module(EngineModuleCmdline(self, "cmdline", fake_stdout)) |
| 44 | + |
| 45 | + def run_cmd_version(self) -> list[str]: |
| 46 | + return [ |
| 47 | + self.get_binary(), |
| 48 | + "--version", |
| 49 | + ] |
| 50 | + |
| 51 | + def run_cmd(self) -> list[str]: |
| 52 | + return [] |
| 53 | + |
| 54 | + def parse_version(self, stdout: bytes, _stderr: bytes) -> bytes: |
| 55 | + self.version = stdout.split(b"-")[1].strip() |
| 56 | + return self.version |
| 57 | + |
| 58 | + def version_major(self) -> int: |
| 59 | + if self.version: |
| 60 | + return int(self.version.split(b".")[0]) |
| 61 | + return 0 |
| 62 | + |
| 63 | + def version_minor(self) -> int: |
| 64 | + if self.version: |
| 65 | + return int(self.version.split(b".")[1]) |
| 66 | + return 0 |
| 67 | + |
| 68 | + def parse_cmd(self, stdout: bytes, stderr: bytes): |
| 69 | + return {} |
| 70 | + |
| 71 | + |
| 72 | +class Fio(ExternalBench): |
| 73 | + """The Fio stressor.""" |
| 74 | + |
| 75 | + def __init__(self, engine_module: EngineModuleBase, parameters: BenchmarkParameters): |
| 76 | + ExternalBench.__init__(self, engine_module, parameters) |
| 77 | + self.parameters = parameters |
| 78 | + self.engine_module = engine_module |
| 79 | + self.log_avg_msec = 20000 # write_*_log are averaged at 20sec |
| 80 | + self._parse_parameters() |
| 81 | + # Tests can skip this part |
| 82 | + if isinstance(parameters.out_dir, pathlib.PosixPath): |
| 83 | + parameters.out_dir.joinpath("fio").mkdir(parents=True, exist_ok=True) |
| 84 | + |
| 85 | + def version_compatible(self) -> bool: |
| 86 | + engine = self.engine_module.get_engine() |
| 87 | + return engine.version_major() >= 3 and engine.version_minor() >= 19 |
| 88 | + |
| 89 | + def _parse_parameters(self): |
| 90 | + self.runtime = self.parameters.runtime |
| 91 | + if self.runtime * 1000 < self.log_avg_msec: |
| 92 | + fatal(f"Fio runtime cannot be lower than the average log time ({self.log_avg_msec}).") |
| 93 | + |
| 94 | + def need_skip_because_version(self): |
| 95 | + if self.skip: |
| 96 | + # we already skipped this benchmark, we can't know the reason anymore |
| 97 | + # because we might not have run the version command. |
| 98 | + return ["echo", "skipped benchmark"] |
| 99 | + if not self.version_compatible(): |
| 100 | + print(f"WARNING: skipping benchmark {self.name}, needs fio >= 3.19") |
| 101 | + self.skip = True |
| 102 | + return ["echo", "skipped benchmark"] |
| 103 | + return None |
| 104 | + |
| 105 | + def run_cmd(self) -> list[str]: |
| 106 | + skip = self.need_skip_because_version() |
| 107 | + if skip: |
| 108 | + return skip |
| 109 | + |
| 110 | + # Let's build the command line to run the tool |
| 111 | + args = [ |
| 112 | + self.engine_module.get_engine().get_binary(), |
| 113 | + ] |
| 114 | + |
| 115 | + return self.get_taskset(args) |
| 116 | + |
| 117 | + def get_default_fio_command_line(self, args: list) -> list: |
| 118 | + """Return the default fio arguments""" |
| 119 | + |
| 120 | + def remove_arg(args, item) -> list: |
| 121 | + if isinstance(item, str): |
| 122 | + return [arg for arg in args if arg != item] |
| 123 | + else: |
| 124 | + # We need to ensure that value based items are having the right value |
| 125 | + # This avoid a case where the user already defined a value we need to control |
| 126 | + i = 0 |
| 127 | + while i < len(args): |
| 128 | + arg = args[i] |
| 129 | + removed = "" |
| 130 | + if arg == item[0]: |
| 131 | + removed = args.pop(i) |
| 132 | + removed += " " + args.pop(i) |
| 133 | + elif arg.startswith(f"{item[0]}="): |
| 134 | + removed = args.pop(i) |
| 135 | + if removed: |
| 136 | + print( |
| 137 | + f"{self.parameters.get_name_with_position()}: Fio parameter {item[0]} is now set to {item[1]} (was: {removed})" |
| 138 | + ) |
| 139 | + else: |
| 140 | + i += 1 |
| 141 | + return args |
| 142 | + |
| 143 | + name = self.parameters.get_name_with_position() |
| 144 | + enforced_items = [ |
| 145 | + ["--runtime", f"{self.parameters.get_runtime()}"], |
| 146 | + "--time_based", |
| 147 | + ["--output-format", "json+"], |
| 148 | + ["--numjobs", self.parameters.get_engine_instances_count()], |
| 149 | + ["--name", name], |
| 150 | + ["--invalidate", 1], |
| 151 | + ["--log_avg_msec", self.log_avg_msec], |
| 152 | + ] |
| 153 | + for log_type in ["bw", "lat", "hist", "iops"]: |
| 154 | + enforced_items.append([f"--write_{log_type}_log", f"fio/{name}_{log_type}.log"]) |
| 155 | + |
| 156 | + for enforced_item in enforced_items: |
| 157 | + args = remove_arg(args, enforced_item) |
| 158 | + if isinstance(enforced_item, str): |
| 159 | + args.append(enforced_item) |
| 160 | + else: |
| 161 | + args.append(f"{enforced_item[0]}={enforced_item[1]}") |
| 162 | + |
| 163 | + return args |
| 164 | + |
| 165 | + def parse_cmd(self, stdout: bytes, stderr: bytes) -> dict[str, Any]: |
| 166 | + if self.skip: |
| 167 | + return self.parameters.get_result_format() | self.empty_result() |
| 168 | + try: |
| 169 | + ret = json.loads(stdout) |
| 170 | + except json.decoder.JSONDecodeError: |
| 171 | + print(f"{self.parameters.get_name_with_position()}: Cannot load fio's JSON output") |
| 172 | + print(f"stdout:\n{stdout.decode()}\nstderr:{stderr.decode()}") |
| 173 | + return self.parameters.get_result_format() | self.empty_result() |
| 174 | + |
| 175 | + return {"fio_results": ret} | self.parameters.get_result_format() |
| 176 | + |
| 177 | + @property |
| 178 | + def name(self) -> str: |
| 179 | + return self.engine_module.get_engine().get_name() |
| 180 | + |
| 181 | + def run_cmd_version(self) -> list[str]: |
| 182 | + return self.engine_module.get_engine().run_cmd_version() |
| 183 | + |
| 184 | + def parse_version(self, stdout: bytes, _stderr: bytes) -> bytes: |
| 185 | + return self.engine_module.get_engine().parse_version(stdout, _stderr) |
| 186 | + |
| 187 | + def empy_result(self): |
| 188 | + """Default empty results for fio""" |
| 189 | + return { |
| 190 | + "effective_runtime": 0, |
| 191 | + "skipped": self.skip, |
| 192 | + "fio_results": {"jobs": []}, |
| 193 | + } |
| 194 | + |
| 195 | + |
| 196 | +class FioCmdLine(Fio): |
| 197 | + def parse_parameters(self): |
| 198 | + """Removing fio arguments set by the engine""" |
| 199 | + # We need to ensure we have a proper fio command line |
| 200 | + # Let's remove duplicated and enforce some |
| 201 | + args = self.parameters.get_engine_module_parameter_base().split() |
| 202 | + |
| 203 | + # Overriding empb to represent the real executed command. |
| 204 | + # The list is having unique members and sorted to ensure a constant string representation. |
| 205 | + self.parameters.engine_module_parameter_base = " ".join(list(self.get_default_fio_command_line(args))) |
| 206 | + |
| 207 | + def run_cmd(self) -> list[str]: |
| 208 | + # Let's build the command line to run the tool |
| 209 | + return super().run_cmd() + self.parameters.get_engine_module_parameter_base().split() |
0 commit comments