github/ocf
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Store PP config params in cache superblock.

Browse Source 
It allows to modify and retrieve particular PP params event if it isn't active
and store values between cache stop and load.

Signed-off-by: Michal Mielewczyk <michal.mielewczyk@intel.com>
This commit is contained in:
Michal Mielewczyk 2019-09-27 02:30:48 -04:00
parent 75569ecaba
commit dfc55538ce
11 changed files with 162 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
inc/ocf_mngt.h
View File

@ -814,26 +814,28 @@ ocf_promotion_t ocf_mngt_cache_promotion_get_policy(ocf_cache_t cache);
*
* @param[in] cache Cache handle
* @param[in] param_id Promotion policy parameter id
* @param[in] type Promotion policy type
* @param[in] param_value Promotion policy parameter value
*
* @retval 0 Parameter has been set successfully
* @retval Non-zero Error occurred and parameter has not been set
*/
int ocf_mngt_cache_promotion_set_param(ocf_cache_t cache, uint8_t param_id,
uint32_t param_value);
ocf_promotion_t type, uint32_t param_value);
/**
* @brief Get promotion policy parameter for given cache
*
* @param[in] cache Cache handle
* @param[in] param_id Promotion policy parameter id
* @param[in] type Promotion policy type
* @param[out] param_value Variable to store parameter value
*
* @retval 0 Parameter has been retrieved successfully
* @retval Non-zero Error occurred and parameter has not been retrieved
*/
int ocf_mngt_cache_promotion_get_param(ocf_cache_t cache, uint8_t param_id,
uint32_t *param_value);
ocf_promotion_t type, uint32_t *param_value);
/**
* @brief IO class configuration

4
src/metadata/metadata_superblock.h
View File

@ -42,8 +42,10 @@ struct ocf_superblock_config {
ocf_cleaning_t cleaning_policy_type;
struct cleaning_policy_config cleaning[CLEANING_POLICY_TYPE_MAX];
ocf_eviction_t eviction_policy_type;
ocf_promotion_t promotion_policy_type;
struct promotion_policy_config promotion[PROMOTION_POLICY_TYPE_MAX];
ocf_eviction_t eviction_policy_type;
/* Current core sequence number */
ocf_core_id_t curr_core_seq_no;

27
src/mngt/ocf_mngt_cache.c
View File

@ -23,6 +23,7 @@
#include "../ocf_ctx_priv.h"
#include "../ocf_freelist.h"
#include "../cleaning/cleaning.h"
#include "../promotion/ops.h"
#define OCF_ASSERT_PLUGGED(cache) ENV_BUG_ON(!(cache)->device)
@ -245,8 +246,16 @@ static void __init_eviction_policy(ocf_cache_t cache,
static ocf_error_t __init_promotion_policy(ocf_cache_t cache)
{
int i;
OCF_ASSERT_PLUGGED(cache);
ENV_BUG_ON(cache->promotion_policy);
for (i = 0; i < ocf_promotion_max; i++) {
if (ocf_promotion_policies[i].setup)
ocf_promotion_policies[i].setup(cache);
}
return ocf_promotion_init(cache, &cache->promotion_policy);
}
@ -467,7 +476,7 @@ void _ocf_mngt_init_instance_load_complete(void *priv, int error)
__init_freelist(cache);
result = __init_promotion_policy(cache);
result = ocf_promotion_init(cache, &cache->promotion_policy);
if (result) {
ocf_cache_log(cache, log_err,
"Cannot initialize promotion policy\n");
@ -1169,8 +1178,6 @@ static void _ocf_mngt_cache_init(ocf_cache_t cache,
*/
cache->conf_meta->cache_mode = params->metadata.cache_mode;
cache->conf_meta->metadata_layout = params->metadata.layout;
cache->conf_meta->promotion_policy_type =
params->metadata.promotion_policy;
INIT_LIST_HEAD(&cache->io_queues);
@ -2276,14 +2283,13 @@ ocf_promotion_t ocf_mngt_cache_promotion_get_policy(ocf_cache_t cache)
}
int ocf_mngt_cache_promotion_get_param(ocf_cache_t cache, uint8_t param_id,
uint32_t *param_value)
ocf_promotion_t type, uint32_t *param_value)
{
int result;
ocf_metadata_start_shared_access(&cache->metadata.lock);
result = ocf_promotion_get_param(cache->promotion_policy, param_id,
param_value);
result = ocf_promotion_get_param(cache, param_id, type, param_value);
ocf_metadata_end_shared_access(&cache->metadata.lock);
@ -2291,16 +2297,15 @@ int ocf_mngt_cache_promotion_get_param(ocf_cache_t cache, uint8_t param_id,
}
int ocf_mngt_cache_promotion_set_param(ocf_cache_t cache, uint8_t param_id,
uint32_t param_value)
ocf_promotion_t type, uint32_t param_value)
{
int result;
ocf_metadata_start_shared_access(&cache->metadata.lock);
ocf_metadata_start_exclusive_access(&cache->metadata.lock);
result = ocf_promotion_set_param(cache->promotion_policy, param_id,
param_value);
result = ocf_promotion_set_param(cache, param_id, type, param_value);
ocf_metadata_end_shared_access(&cache->metadata.lock);
ocf_metadata_end_exclusive_access(&cache->metadata.lock);
return result;
}

65
src/promotion/nhit/nhit.c
View File

@ -15,12 +15,18 @@
struct nhit_policy_context {
nhit_hash_t hash_map;
/* Configurable parameters */
env_atomic insertion_threshold;
env_atomic trigger_threshold;
};
void nhit_setup(ocf_cache_t cache)
{
struct nhit_promotion_policy_config *cfg;
cfg = (void *) &cache->conf_meta->promotion[ocf_promotion_nhit].data;
cfg->insertion_threshold = OCF_NHIT_THRESHOLD_DEFAULT;
cfg->trigger_threshold = OCF_NHIT_TRIGGER_DEFAULT;
}
ocf_error_t nhit_init(ocf_cache_t cache, ocf_promotion_policy_t policy)
{
struct nhit_policy_context *ctx;
@ -37,8 +43,6 @@ ocf_error_t nhit_init(ocf_cache_t cache, ocf_promotion_policy_t policy)
if (result)
goto dealloc_ctx;
env_atomic_set(&ctx->insertion_threshold, OCF_NHIT_THRESHOLD_DEFAULT);
env_atomic_set(&ctx->trigger_threshold, OCF_NHIT_TRIGGER_DEFAULT);
policy->ctx = ctx;
return 0;
@ -60,22 +64,24 @@ void nhit_deinit(ocf_promotion_policy_t policy)
policy->ctx = NULL;
}
ocf_error_t nhit_set_param(ocf_promotion_policy_t policy, uint8_t param_id,
ocf_error_t nhit_set_param(ocf_cache_t cache, uint8_t param_id,
uint32_t param_value)
{
struct nhit_policy_context *ctx = policy->ctx;
struct nhit_promotion_policy_config *cfg;
ocf_error_t result = 0;
cfg = (void *) &cache->conf_meta->promotion[ocf_promotion_nhit].data;
switch (param_id) {
case ocf_nhit_insertion_threshold:
if (param_value >= OCF_NHIT_MIN_THRESHOLD &&
param_value <= OCF_NHIT_MAX_THRESHOLD) {
env_atomic_set(&ctx->insertion_threshold, param_value);
ocf_cache_log(policy->owner, log_info,
cfg->insertion_threshold = param_value;
ocf_cache_log(cache, log_info,
"Nhit PP insertion threshold value set to %u",
param_value);
} else {
ocf_cache_log(policy->owner, log_err, "Invalid nhit "
ocf_cache_log(cache, log_err, "Invalid nhit "
"promotion policy insertion threshold!\n");
result = -OCF_ERR_INVAL;
}
@ -84,12 +90,12 @@ ocf_error_t nhit_set_param(ocf_promotion_policy_t policy, uint8_t param_id,
case ocf_nhit_trigger_threshold:
if (param_value >= OCF_NHIT_MIN_TRIGGER &&
param_value <= OCF_NHIT_MAX_TRIGGER) {
env_atomic_set(&ctx->trigger_threshold, param_value);
ocf_cache_log(policy->owner, log_info,
cfg->trigger_threshold = param_value;
ocf_cache_log(cache, log_info,
"Nhit PP trigger threshold value set to %u%%\n",
param_value);
} else {
ocf_cache_log(policy->owner, log_err, "Invalid nhit "
ocf_cache_log(cache, log_err, "Invalid nhit "
"promotion policy insertion trigger "
"threshold!\n");
result = -OCF_ERR_INVAL;
@ -97,7 +103,7 @@ ocf_error_t nhit_set_param(ocf_promotion_policy_t policy, uint8_t param_id,
break;
default:
ocf_cache_log(policy->owner, log_err, "Invalid nhit "
ocf_cache_log(cache, log_err, "Invalid nhit "
"promotion policy parameter (%u)!\n",
param_id);
result = -OCF_ERR_INVAL;
@ -108,23 +114,25 @@ ocf_error_t nhit_set_param(ocf_promotion_policy_t policy, uint8_t param_id,
return result;
}
ocf_error_t nhit_get_param(ocf_promotion_policy_t policy, uint8_t param_id,
ocf_error_t nhit_get_param(ocf_cache_t cache, uint8_t param_id,
uint32_t *param_value)
{
struct nhit_policy_context *ctx = policy->ctx;
struct nhit_promotion_policy_config *cfg;
ocf_error_t result = 0;
cfg = (void *) &cache->conf_meta->promotion[ocf_promotion_nhit].data;
OCF_CHECK_NULL(param_value);
switch (param_id) {
case ocf_nhit_insertion_threshold:
*param_value = env_atomic_read(&ctx->insertion_threshold);
*param_value = cfg->insertion_threshold;
break;
case ocf_nhit_trigger_threshold:
*param_value = env_atomic_read(&ctx->trigger_threshold);
*param_value = cfg->trigger_threshold;
break;
default:
ocf_cache_log(policy->owner, log_err, "Invalid nhit "
ocf_cache_log(cache, log_err, "Invalid nhit "
"promotion policy parameter (%u)!\n",
param_id);
result = -OCF_ERR_INVAL;
@ -156,16 +164,21 @@ void nhit_req_purge(ocf_promotion_policy_t policy,
}
}
static bool core_line_should_promote(struct nhit_policy_context *ctx,
static bool core_line_should_promote(ocf_promotion_policy_t policy,
ocf_core_id_t core_id, uint64_t core_lba)
{
struct nhit_promotion_policy_config *cfg;
struct nhit_policy_context *ctx;
bool hit;
int32_t counter;
cfg = (void *)&policy->owner->conf_meta->promotion[ocf_promotion_nhit].data;
ctx = policy->ctx;
hit = nhit_hash_query(ctx->hash_map, core_id, core_lba, &counter);
if (hit) {
/* we have a hit, return now */
return env_atomic_read(&ctx->insertion_threshold) <= counter;
return cfg->insertion_threshold <= counter;
}
nhit_hash_insert(ctx->hash_map, core_id, core_lba);
@ -176,7 +189,7 @@ static bool core_line_should_promote(struct nhit_policy_context *ctx,
bool nhit_req_should_promote(ocf_promotion_policy_t policy,
struct ocf_request *req)
{
struct nhit_policy_context *ctx = policy->ctx;
struct nhit_promotion_policy_config *cfg;
bool result = true;
uint32_t i;
uint64_t core_line;
@ -184,8 +197,10 @@ bool nhit_req_should_promote(ocf_promotion_policy_t policy,
ocf_metadata_collision_table_entries(policy->owner) -
ocf_freelist_num_free(policy->owner->freelist);
cfg = (void *)&policy->owner->conf_meta->promotion[ocf_promotion_nhit].data;
if (occupied_cachelines < OCF_DIV_ROUND_UP(
((uint64_t) env_atomic_read(&ctx->trigger_threshold) *
((uint64_t)cfg->trigger_threshold *
ocf_metadata_get_cachelines_count(policy->owner)), 100))
return true;
@ -193,7 +208,7 @@ bool nhit_req_should_promote(ocf_promotion_policy_t policy,
core_line <= req->core_line_last; core_line++, i++) {
struct ocf_map_info *entry = &(req->map[i]);
if (!core_line_should_promote(ctx, entry->core_id,
if (!core_line_should_promote(policy, entry->core_id,
entry->core_line)) {
result = false;
}

7
src/promotion/nhit/nhit.h
View File

@ -9,15 +9,18 @@
#include "ocf/ocf.h"
#include "../../ocf_request.h"
#include "../promotion.h"
#include "nhit_structs.h"
void nhit_setup(ocf_cache_t cache);
ocf_error_t nhit_init(ocf_cache_t cache, ocf_promotion_policy_t policy);
void nhit_deinit(ocf_promotion_policy_t policy);
ocf_error_t nhit_set_param(ocf_promotion_policy_t policy, uint8_t param_id,
ocf_error_t nhit_set_param(ocf_cache_t cache, uint8_t param_id,
uint32_t param_value);
ocf_error_t nhit_get_param(ocf_promotion_policy_t policy, uint8_t param_id,
ocf_error_t nhit_get_param(ocf_cache_t cache, uint8_t param_id,
uint32_t *param_value);
void nhit_req_purge(ocf_promotion_policy_t policy,

16
src/promotion/nhit/nhit_structs.h Normal file
View File

@ -0,0 +1,16 @@
/*
* Copyright(c) 2012-2019 Intel Corporation
* SPDX-License-Identifier: BSD-3-Clause-Clear
*/
#ifndef __PROMOTION_NHIT_STRUCTS_H_
#define __PROMOTION_NHIT_STRUCTS_H_
struct nhit_promotion_policy_config {
uint32_t insertion_threshold;
/*!< Number of hits */
uint32_t trigger_threshold;
/*!< Cache occupancy (percentage value) */
};
#endif

9
src/promotion/ops.h
View File

@ -20,17 +20,20 @@ struct promotion_policy_ops {
const char *name;
/*!< Promotion policy name */
void (*setup)(ocf_cache_t cache);
/*!< initialize promotion policy default config */
ocf_error_t (*init)(ocf_cache_t cache, ocf_promotion_policy_t policy);
/*!< Allocate and initialize promotion policy */
void (*deinit)(ocf_promotion_policy_t policy);
/*!< Deinit and free promotion policy */
ocf_error_t (*set_param)(ocf_promotion_policy_t policy, uint8_t param_id,
ocf_error_t (*set_param)(ocf_cache_t cache, uint8_t param_id,
uint32_t param_value);
/*!< Set promotion policy parameter */
ocf_error_t (*get_param)(ocf_promotion_policy_t policy, uint8_t param_id,
ocf_error_t (*get_param)(ocf_cache_t cache, uint8_t param_id,
uint32_t *param_value);
/*!< Get promotion policy parameter */
@ -44,5 +47,7 @@ struct promotion_policy_ops {
/*!< Should request lines be inserted into cache */
};
extern struct promotion_policy_ops ocf_promotion_policies[ocf_promotion_max];
#endif /* PROMOTION_OPS_H_ */

15
src/promotion/promotion.c
View File

@ -15,6 +15,7 @@ struct promotion_policy_ops ocf_promotion_policies[ocf_promotion_max] = {
},
[ocf_promotion_nhit] = {
.name = "nhit",
.setup = nhit_setup,
.init = nhit_init,
.deinit = nhit_deinit,
.set_param = nhit_set_param,
@ -95,32 +96,30 @@ ocf_error_t ocf_promotion_set_policy(ocf_promotion_policy_t policy,
return result;
}
ocf_error_t ocf_promotion_set_param(ocf_promotion_policy_t policy,
uint8_t param_id, uint32_t param_value)
ocf_error_t ocf_promotion_set_param(ocf_cache_t cache, uint8_t param_id,
ocf_promotion_t type, uint32_t param_value)
{
ocf_promotion_t type = policy->type;
ocf_error_t result = -OCF_ERR_INVAL;
ENV_BUG_ON(type >= ocf_promotion_max);
if (ocf_promotion_policies[type].set_param) {
result = ocf_promotion_policies[type].set_param(policy, param_id,
result = ocf_promotion_policies[type].set_param(cache, param_id,
param_value);
}
return result;
}
ocf_error_t ocf_promotion_get_param(ocf_promotion_policy_t policy,
uint8_t param_id, uint32_t *param_value)
ocf_error_t ocf_promotion_get_param(ocf_cache_t cache, uint8_t param_id,
ocf_promotion_t type, uint32_t *param_value)
{
ocf_promotion_t type = policy->type;
ocf_error_t result = -OCF_ERR_INVAL;
ENV_BUG_ON(type >= ocf_promotion_max);
if (ocf_promotion_policies[type].get_param) {
result = ocf_promotion_policies[type].get_param(policy, param_id,
result = ocf_promotion_policies[type].get_param(cache, param_id,
param_value);
}

32
src/promotion/promotion.h
View File

@ -9,7 +9,25 @@
#include "ocf/ocf.h"
#include "../ocf_request.h"
#define PROMOTION_POLICY_CONFIG_BYTES 256
#define PROMOTION_POLICY_TYPE_MAX 2
struct promotion_policy_config {
uint8_t data[PROMOTION_POLICY_CONFIG_BYTES];
};
typedef struct ocf_promotion_policy *ocf_promotion_policy_t;
/**
* @brief Initialize promotion policy default values. Should be called after
* cache metadata has been allocated and cache->conf_meta->promotion_policy_type
* has been set.
*
* @param[in] cache OCF cache instance
*/
void ocf_promotion_setup(ocf_cache_t cache);
/**
* @brief Allocate and initialize promotion policy. Should be called after cache
* metadata has been allocated and cache->conf_meta->promotion_policy_type has
@ -44,26 +62,28 @@ ocf_error_t ocf_promotion_set_policy(ocf_promotion_policy_t policy,
/**
* @brief Set promotion policy parameter
*
* @param[in] policy promotion policy handle
* @param[in] cache cache handle
* @param[in] param_id id of parameter to be set
* @param[in] type id of propmotion policy to be configured
* @param[in] param_value value of parameter to be set
*
* @retval ocf_error_t
*/
ocf_error_t ocf_promotion_set_param(ocf_promotion_policy_t policy,
uint8_t param_id, uint32_t param_value);
ocf_error_t ocf_promotion_set_param(ocf_cache_t cache, uint8_t param_id,
ocf_promotion_t type, uint32_t param_value);
/**
* @brief Get promotion policy parameter
*
* @param[in] policy promotion policy handle
* @param[in] cache cache handle
* @param[in] param_id id of parameter to be set
* @param[in] type id of propmotion policy to be configured
* @param[out] param_value value of parameter to be set
*
* @retval ocf_error_t
*/
ocf_error_t ocf_promotion_get_param(ocf_promotion_policy_t policy,
uint8_t param_id, uint32_t *param_value);
ocf_error_t ocf_promotion_get_param(ocf_cache_t cache, uint8_t param_id,
ocf_promotion_t type, uint32_t *param_value);
/**
* @brief Update promotion policy after cache lines have been promoted to cache

80
tests/functional/pyocf/types/cache.py
View File

@ -171,8 +171,7 @@ class Cache:
_metadata_layout=metadata_layout,
_metadata_volatile=metadata_volatile,
_backfill=Backfill(
_max_queue_size=max_queue_size,
_queue_unblock_size=queue_unblock_size,
_max_queue_size=max_queue_size, _queue_unblock_size=queue_unblock_size
),
_locked=locked,
_pt_unaligned_io=pt_unaligned_io,
@ -183,9 +182,7 @@ class Cache:
self.io_queues = []
self.cores = []
def start_cache(
self, default_io_queue: Queue = None, mngt_queue: Queue = None
):
def start_cache(self, default_io_queue: Queue = None, mngt_queue: Queue = None):
status = self.owner.lib.ocf_mngt_cache_start(
self.owner.ctx_handle, byref(self.cache_handle), byref(self.cfg)
)
@ -193,20 +190,14 @@ class Cache:
raise OcfError("Creating cache instance failed", status)
self.owner.caches.append(self)
self.mngt_queue = mngt_queue or Queue(
self, "mgmt-{}".format(self.get_name())
)
self.mngt_queue = mngt_queue or Queue(self, "mgmt-{}".format(self.get_name()))
if default_io_queue:
self.io_queues += [default_io_queue]
else:
self.io_queues += [
Queue(self, "default-io-{}".format(self.get_name()))
]
self.io_queues += [Queue(self, "default-io-{}".format(self.get_name()))]
status = self.owner.lib.ocf_mngt_cache_set_mngt_queue(
self, self.mngt_queue
)
status = self.owner.lib.ocf_mngt_cache_set_mngt_queue(self, self.mngt_queue)
if status:
raise OcfError("Error setting management queue", status)
@ -214,9 +205,7 @@ class Cache:
def change_cache_mode(self, cache_mode: CacheMode):
self.write_lock()
status = self.owner.lib.ocf_mngt_cache_set_mode(
self.cache_handle, cache_mode
)
status = self.owner.lib.ocf_mngt_cache_set_mode(self.cache_handle, cache_mode)
self.write_unlock()
@ -260,13 +249,13 @@ class Cache:
if status:
raise OcfError("Error setting promotion policy", status)
def get_promotion_policy_param(self, param_id):
def get_promotion_policy_param(self, promotion_type, param_id):
self.read_lock()
param_value = c_uint64()
status = self.owner.lib.ocf_mngt_cache_promotion_get_param(
self.cache_handle, param_id, byref(param_value)
self.cache_handle, param_id, promotion_type, byref(param_value)
)
self.read_unlock()
@ -275,11 +264,11 @@ class Cache:
return param_value
def set_promotion_policy_param(self, param_id, param_value):
def set_promotion_policy_param(self, param_id, promotion_type, param_value):
self.write_lock()
status = self.owner.lib.ocf_mngt_cache_promotion_set_param(
self.cache_handle, param_id, param_value
self.cache_handle, param_id, promotion_type, param_value
)
self.write_unlock()
@ -306,8 +295,7 @@ class Cache:
self.dev_cfg = CacheDeviceConfig(
_uuid=Uuid(
_data=cast(
create_string_buffer(self.device_name.encode("ascii")),
c_char_p,
create_string_buffer(self.device_name.encode("ascii")), c_char_p
),
_size=len(self.device_name) + 1,
),
@ -327,9 +315,7 @@ class Cache:
self.configure_device(device, force, perform_test, cache_line_size)
self.write_lock()
c = OcfCompletion(
[("cache", c_void_p), ("priv", c_void_p), ("error", c_int)]
)
c = OcfCompletion([("cache", c_void_p), ("priv", c_void_p), ("error", c_int)])
device.owner.lib.ocf_mngt_cache_attach(
self.cache_handle, byref(self.dev_cfg), c, None
@ -343,9 +329,7 @@ class Cache:
def load_cache(self, device):
self.configure_device(device)
c = OcfCompletion(
[("cache", c_void_p), ("priv", c_void_p), ("error", c_int)]
)
c = OcfCompletion([("cache", c_void_p), ("priv", c_void_p), ("error", c_int)])
device.owner.lib.ocf_mngt_cache_load(
self.cache_handle, byref(self.dev_cfg), c, None
)
@ -389,18 +373,14 @@ class Cache:
raise OcfError("Couldn't get cache instance", status)
def read_lock(self):
c = OcfCompletion(
[("cache", c_void_p), ("priv", c_void_p), ("error", c_int)]
)
c = OcfCompletion([("cache", c_void_p), ("priv", c_void_p), ("error", c_int)])
self.owner.lib.ocf_mngt_cache_read_lock(self.cache_handle, c, None)
c.wait()
if c.results["error"]:
raise OcfError("Couldn't lock cache instance", c.results["error"])
def write_lock(self):
c = OcfCompletion(
[("cache", c_void_p), ("priv", c_void_p), ("error", c_int)]
)
c = OcfCompletion([("cache", c_void_p), ("priv", c_void_p), ("error", c_int)])
self.owner.lib.ocf_mngt_cache_lock(self.cache_handle, c, None)
c.wait()
if c.results["error"]:
@ -463,19 +443,13 @@ class Cache:
self.read_lock()
status = self.owner.lib.ocf_cache_get_info(
self.cache_handle, byref(cache_info)
)
status = self.owner.lib.ocf_cache_get_info(self.cache_handle, byref(cache_info))
if status:
self.read_unlock()
raise OcfError("Failed getting cache info", status)
status = self.owner.lib.ocf_stats_collect_cache(
self.cache_handle,
byref(usage),
byref(req),
byref(block),
byref(errors),
self.cache_handle, byref(usage), byref(req), byref(block), byref(errors)
)
if status:
self.read_unlock()
@ -494,12 +468,8 @@ class Cache:
"occupancy": CacheLines(
cache_info.inactive.occupancy.value, line_size
),
"dirty": CacheLines(
cache_info.inactive.dirty.value, line_size
),
"clean": CacheLines(
cache_info.inactive.clean.value, line_size
),
"dirty": CacheLines(cache_info.inactive.dirty.value, line_size),
"clean": CacheLines(cache_info.inactive.clean.value, line_size),
},
"occupancy": CacheLines(cache_info.occupancy, line_size),
"dirty": CacheLines(cache_info.dirty, line_size),
@ -541,9 +511,7 @@ class Cache:
raise Exception("Not started!")
self.get_and_write_lock()
c = OcfCompletion(
[("cache", c_void_p), ("priv", c_void_p), ("error", c_int)]
)
c = OcfCompletion([("cache", c_void_p), ("priv", c_void_p), ("error", c_int)])
self.owner.lib.ocf_mngt_cache_save(self.cache_handle, c, None)
c.wait()
@ -558,9 +526,7 @@ class Cache:
self.write_lock()
c = OcfCompletion(
[("cache", c_void_p), ("priv", c_void_p), ("error", c_int)]
)
c = OcfCompletion([("cache", c_void_p), ("priv", c_void_p), ("error", c_int)])
self.owner.lib.ocf_mngt_cache_stop(self.cache_handle, c, None)
@ -580,9 +546,7 @@ class Cache:
def flush(self):
self.write_lock()
c = OcfCompletion(
[("cache", c_void_p), ("priv", c_void_p), ("error", c_int)]
)
c = OcfCompletion([("cache", c_void_p), ("priv", c_void_p), ("error", c_int)])
self.owner.lib.ocf_mngt_cache_flush(self.cache_handle, c, None)
c.wait()
self.write_unlock()

52
tests/functional/tests/engine/test_pp.py
View File

@ -7,11 +7,7 @@ from ctypes import c_int
import pytest
import math
from pyocf.types.cache import (
Cache,
PromotionPolicy,
NhitParams,
)
from pyocf.types.cache import Cache, PromotionPolicy, NhitParams
from pyocf.types.core import Core
from pyocf.types.volume import Volume
from pyocf.types.data import Data
@ -71,12 +67,7 @@ def test_change_to_nhit_and_back_io_in_flight(pyocf_ctx):
comp = OcfCompletion([("error", c_int)])
write_data = Data(4096)
io = core.new_io(
cache.get_default_queue(),
i * 4096,
write_data.size,
IoDir.WRITE,
0,
0,
cache.get_default_queue(), i * 4096, write_data.size, IoDir.WRITE, 0, 0
)
completions += [comp]
io.set_data(write_data)
@ -89,9 +80,7 @@ def test_change_to_nhit_and_back_io_in_flight(pyocf_ctx):
# Step 4
for c in completions:
c.wait()
assert not c.results[
"error"
], "No IO's should fail when turning NHIT policy on"
assert not c.results["error"], "No IO's should fail when turning NHIT policy on"
# Step 5
completions = []
@ -99,12 +88,7 @@ def test_change_to_nhit_and_back_io_in_flight(pyocf_ctx):
comp = OcfCompletion([("error", c_int)])
write_data = Data(4096)
io = core.new_io(
cache.get_default_queue(),
i * 4096,
write_data.size,
IoDir.WRITE,
0,
0,
cache.get_default_queue(), i * 4096, write_data.size, IoDir.WRITE, 0, 0
)
completions += [comp]
io.set_data(write_data)
@ -157,9 +141,7 @@ def fill_cache(cache, fill_ratio):
if bytes_to_fill % max_io_size:
comp = OcfCompletion([("error", c_int)])
write_data = Data(
Size.from_B(bytes_to_fill % max_io_size, sector_aligned=True)
)
write_data = Data(Size.from_B(bytes_to_fill % max_io_size, sector_aligned=True))
io = core.new_io(
cache.get_default_queue(),
ios_to_issue * max_io_size,
@ -198,18 +180,16 @@ def test_promoted_after_hits_various_thresholds(
cache_device = Volume(Size.from_MiB(30))
core_device = Volume(Size.from_MiB(30))
cache = Cache.start_on_device(
cache_device, promotion_policy=PromotionPolicy.NHIT
)
cache = Cache.start_on_device(cache_device, promotion_policy=PromotionPolicy.NHIT)
core = Core.using_device(core_device)
cache.add_core(core)
# Step 2
cache.set_promotion_policy_param(
NhitParams.TRIGGER_THRESHOLD, fill_percentage
NhitParams.TRIGGER_THRESHOLD, PromotionPolicy.NHIT, fill_percentage
)
cache.set_promotion_policy_param(
NhitParams.INSERTION_THRESHOLD, insertion_threshold
NhitParams.INSERTION_THRESHOLD, PromotionPolicy.NHIT, insertion_threshold
)
# Step 3
fill_cache(cache, fill_percentage / 100)
@ -290,9 +270,7 @@ def test_partial_hit_promotion(pyocf_ctx):
# Step 2
comp = OcfCompletion([("error", c_int)])
write_data = Data(Size.from_sector(1))
io = core.new_io(
cache.get_default_queue(), 0, write_data.size, IoDir.READ, 0, 0
)
io = core.new_io(cache.get_default_queue(), 0, write_data.size, IoDir.READ, 0, 0)
io.set_data(write_data)
io.callback = comp.callback
io.submit()
@ -305,15 +283,17 @@ def test_partial_hit_promotion(pyocf_ctx):
# Step 3
cache.set_promotion_policy(PromotionPolicy.NHIT)
cache.set_promotion_policy_param(NhitParams.TRIGGER_THRESHOLD, 0)
cache.set_promotion_policy_param(NhitParams.INSERTION_THRESHOLD, 100)
cache.set_promotion_policy_param(
NhitParams.TRIGGER_THRESHOLD, PromotionPolicy.NHIT, 0
)
cache.set_promotion_policy_param(
NhitParams.INSERTION_THRESHOLD, PromotionPolicy.NHIT, 100
)
# Step 4
comp = OcfCompletion([("error", c_int)])
write_data = Data(2 * cache_lines.line_size)
io = core.new_io(
cache.get_default_queue(), 0, write_data.size, IoDir.WRITE, 0, 0
)
io = core.new_io(cache.get_default_queue(), 0, write_data.size, IoDir.WRITE, 0, 0)
io.set_data(write_data)
io.callback = comp.callback
io.submit()