def test_start_read_first_and_check_mode(pyocf_ctx, mode: CacheMode, cls: CacheLineSize):
"""Starting cache in different modes with different cache line sizes.
After start check proper cache mode behaviour, starting with read operation.
"""
cache_device = Volume(Size.from_MiB(20))
core_device = Volume(Size.from_MiB(5))
cache = Cache.start_on_device(cache_device, cache_mode=mode, cache_line_size=cls)
core_exported = Core.using_device(core_device)
cache.add_core(core_exported)
logger.info("[STAGE] Initial write to core device")
test_data = Data.from_string("This is test data")
io_to_core(core_exported, test_data, Size.from_sector(1).B, True)
cache_device.reset_stats()
core_device.reset_stats()
logger.info("[STAGE] Initial read from exported object")
io_from_exported_object(core_exported, test_data.size, Size.from_sector(1).B)
check_stats_read_empty(core_exported, mode, cls)
logger.info("[STAGE] Write to exported object after initial read")
cache_device.reset_stats()
core_device.reset_stats()
test_data = Data.from_string("Changed test data")
io_to_core(core_exported, test_data, Size.from_sector(1).B)
check_stats_write_after_read(core_exported, mode, cls, True)
logger.info("[STAGE] Read from exported object after write")
io_from_exported_object(core_exported, test_data.size, Size.from_sector(1).B)
check_stats_read_after_write(core_exported, mode, cls)
check_md5_sums(core_exported, mode)
def try_start_cache(**config):
cache_device = Volume(Size.from_MiB(30))
cache = Cache.start_on_device(cache_device, **config)
cache.stop()
def test_seq_cutoff_max_streams(pyocf_ctx):
"""
Test number of sequential streams tracked by OCF.
MAX_STREAMS is the maximal amount of streams which OCF is able to track.
1. Issue MAX_STREAMS requests (write or reads) to cache, 1 sector shorter than
seq cutoff threshold
2. Issue MAX_STREAMS-1 requests continuing the streams from 1. to surpass the threshold and
check if cutoff was triggered (requests used PT engine)
3. Issue single request to stream not used in 1. or 2. and check if it's been handled by cache
4. Issue single request to stream least recently used in 1. and 2. and check if it's been
handled by cache. It should no longer be tracked by OCF, because of request in step 3. which
overflowed the OCF handling structure)
"""
MAX_STREAMS = 256
TEST_STREAMS = MAX_STREAMS + 1 # Number of streams used by test - one more than OCF can track
core_size = Size.from_MiB(200)
threshold = Size.from_KiB(4)
streams = [
Stream(
last=Size((stream_no * int(core_size) // TEST_STREAMS),
sector_aligned=True),
length=Size(0),
direction=choice(list(IoDir)),
) for stream_no in range(TEST_STREAMS)
] # Generate MAX_STREAMS + 1 non-overlapping streams
# Remove one stream - this is the one we are going to use to overflow OCF tracking structure
# in step 3
non_active_stream = choice(streams)
streams.remove(non_active_stream)
cache = Cache.start_on_device(Volume(Size.from_MiB(200)),
cache_mode=CacheMode.WT)
core = Core.using_device(Volume(core_size))
cache.add_core(core)
cache.set_seq_cut_off_policy(SeqCutOffPolicy.ALWAYS)
cache.set_seq_cut_off_threshold(threshold)
# STEP 1
shuffle(streams)
io_size = threshold - Size.from_sector(1)
io_to_streams(core, streams, io_size)
stats = cache.get_stats()
assert (stats["req"]["serviced"]["value"] == stats["req"]["total"]["value"]
== len(streams)), "All request should be serviced - no cutoff"
old_serviced = len(streams)
# STEP 2
lru_stream = streams[0]
streams.remove(lru_stream)
shuffle(streams)
io_to_streams(core, streams, Size.from_sector(1))
stats = cache.get_stats()
assert (
stats["req"]["serviced"]["value"] == old_serviced
), "Serviced requests stat should not increase - cutoff engaged for all"
assert stats["req"]["wr_pt"]["value"] + stats["req"]["rd_pt"][
"value"] == len(
streams
), "All streams should be handled in PT - cutoff engaged for all streams"
# STEP 3
io_to_streams(core, [non_active_stream], Size.from_sector(1))
stats = cache.get_stats()
assert (
stats["req"]["serviced"]["value"] == old_serviced + 1
), "This request should be serviced by cache - no cutoff for inactive stream"
# STEP 4
io_to_streams(core, [lru_stream], Size.from_sector(1))
stats = cache.get_stats()
assert (
stats["req"]["serviced"]["value"] == old_serviced + 2
), "This request should be serviced by cache - lru_stream should be no longer tracked"
def test_load_cache_no_preexisting_data(pyocf_ctx):
cache_device = Volume(S.from_MiB(30))
with pytest.raises(OcfError, match="OCF_ERR_NO_METADATA"):
cache = Cache.load_from_device(cache_device)
def test_load_cache_no_preexisting_data(pyocf_ctx):
cache_device = Volume(S.from_MiB(100))
with pytest.raises(OcfError, match="OCF_ERR_START_CACHE_FAIL"):
cache = Cache.load_from_device(cache_device)