From 460cbe7cccc280b1fed1730cbd7eab661ed1ad5e Mon Sep 17 00:00:00 2001 From: Ostrokrzew Date: Mon, 23 Dec 2019 15:02:11 +0100 Subject: [PATCH] Add stress test for small caches Add IO stress tests for small CAS devices with 1 or 4 cores for every cache mode and cache line size and with every cleaning policy for WB and WO modes. Signed-off-by: Slawomir Jankowski --- .../stress/test_stress_io_small_device.py | 107 ++++++++++++++++++ 1 file changed, 107 insertions(+) create mode 100644 test/functional/tests/stress/test_stress_io_small_device.py diff --git a/test/functional/tests/stress/test_stress_io_small_device.py b/test/functional/tests/stress/test_stress_io_small_device.py new file mode 100644 index 000000000..8982c198e --- /dev/null +++ b/test/functional/tests/stress/test_stress_io_small_device.py @@ -0,0 +1,107 @@ +# +# Copyright(c) 2019 Intel Corporation +# SPDX-License-Identifier: BSD-3-Clause-Clear +# + +import pytest +from datetime import timedelta + +from api.cas import casadm, casadm_parser +from api.cas.cache_config import CacheLineSize, CacheMode, CleaningPolicy +from core.test_run import TestRun +from storage_devices.disk import DiskType, DiskTypeLowerThan, DiskTypeSet +from test_tools.fio.fio import Fio +from test_tools.fio.fio_param import CpusAllowedPolicy, IoEngine, ReadWrite +from test_utils.size import Size, Unit + +stress_time = timedelta(minutes=30) + + +@pytest.mark.parametrize("cores_number", [1, 4]) +@pytest.mark.parametrize("cache_config", [(CacheMode.WT, None), + (CacheMode.WA, None), + (CacheMode.PT, None), + (CacheMode.WB, CleaningPolicy.acp), + (CacheMode.WB, CleaningPolicy.alru), + (CacheMode.WB, CleaningPolicy.nop), + (CacheMode.WO, CleaningPolicy.acp), + (CacheMode.WO, CleaningPolicy.alru), + (CacheMode.WO, CleaningPolicy.nop)]) +@pytest.mark.parametrize("cache_line_size", CacheLineSize) +@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand])) +@pytest.mark.require_disk("core", DiskTypeLowerThan("cache")) +def test_stress_small_cas_device(cache_line_size, cores_number, cache_config): + """ + title: Stress test for verifying data on small CAS devices. + description: | + Validate the ability of CAS to handle many iops when device is small + using different cache modes, cache line sizes and core numbers. + pass_criteria: + - No system crash. + - Md5 sums of core device and exported object are equal. + """ + cache_mode, cleaning_policy = cache_config + + with TestRun.step(f"Prepare 1 cache and {cores_number} core devices."): + cache_dev = TestRun.disks['cache'] + cache_dev.create_partitions([Size(100, Unit.MebiByte)]) + cache_part = cache_dev.partitions[0] + core_dev = TestRun.disks['core'] + core_sizes = [Size(200, Unit.MebiByte)] * cores_number + core_dev.create_partitions(core_sizes) + + with TestRun.step(f"Start cache with {cores_number} cores."): + cache = casadm.start_cache(cache_part, cache_mode, cache_line_size, force=True) + cores = [] + for i in range(cores_number): + cores.append(cache.add_core(core_dev.partitions[i])) + caches_count = len(casadm_parser.get_caches()) + if caches_count != 1: + TestRun.fail(f"Expected caches count: 1; Actual caches count: {caches_count}.") + cores_count = len(casadm_parser.get_cores(cache.cache_id)) + if cores_count != cores_number: + TestRun.fail( + f"Expected cores count: {cores_number}; Actual cores count: {cores_count}.") + + if cleaning_policy is not None: + with TestRun.step("Set cleaning policy."): + cache.set_cleaning_policy(cleaning_policy) + + with TestRun.step(f"Stress cache for {int(stress_time.total_seconds() / 60)} minutes."): + fio = (Fio().create_command() + .io_engine(IoEngine.libaio) + .io_depth(128) + .direct() + .time_based() + .run_time(stress_time) + .read_write(ReadWrite.randrw) + .block_size(cache_line_size) + .num_jobs(cores_number) + .cpus_allowed_policy(CpusAllowedPolicy.split)) + for core in cores: + fio.add_job(f"job_{core.core_id}").target(core.system_path) + output = fio.run()[0] + TestRun.LOGGER.info(f"Total read I/O [KiB]: {str(output.read_io())}\n" + f"Total write I/O [KiB]: {str(output.write_io())}") + + with TestRun.step("Count md5 sum for exported objects"): + md5sum_core = [] + for core in cores: + md5sum_core.append(TestRun.executor.run( + f"md5sum -b {core.system_path}").stdout.split(" ")[0]) + + with TestRun.step("Stop cache."): + cache.stop() + + with TestRun.step("Count md5 sum for core devices"): + md5sum_core_dev = [] + for core_dev in core_dev.partitions: + md5sum_core_dev.append(TestRun.executor.run( + f"md5sum -b {core_dev.system_path}").stdout.split(" ")[0]) + + with TestRun.step("Compare md5 sum of exported objects and cores."): + if md5sum_core_dev != md5sum_core: + TestRun.LOGGER.error(f"Md5 sums of core devices and of exported objects are different.") + + with TestRun.step("Stop all caches"): + casadm.stop_all_caches()