Store PP config params in cache superblock.

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>

inc/ocf_mngt.h

@@ -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

src/metadata/metadata_superblock.h

@@ -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;

src/mngt/ocf_mngt_cache.c

@@ -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,
+	result = ocf_promotion_get_param(cache, param_id, type, param_value);
-			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,
+	result = ocf_promotion_set_param(cache, param_id, type, param_value);
-			param_value);
 
-	ocf_metadata_end_shared_access(&cache->metadata.lock);
+	ocf_metadata_end_exclusive_access(&cache->metadata.lock);
 
 	return result;
 }

src/promotion/nhit/nhit.c

@@ -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);
+			cfg->insertion_threshold = param_value;
-			ocf_cache_log(policy->owner, log_info,
+			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);
+			cfg->trigger_threshold = param_value;
-			ocf_cache_log(policy->owner, log_info,
+			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;
 		}

src/promotion/nhit/nhit.h

@@ -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,

src/promotion/nhit/nhit_structs.h

@@ -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

src/promotion/ops.h

@@ -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_ */
 

src/promotion/promotion.c

@@ -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,
+ocf_error_t ocf_promotion_set_param(ocf_cache_t cache, uint8_t param_id,
-		uint8_t param_id, uint32_t param_value)
+		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,
+ocf_error_t ocf_promotion_get_param(ocf_cache_t cache, uint8_t param_id,
-		uint8_t param_id, uint32_t *param_value)
+		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);
 	}
 

src/promotion/promotion.h

@@ -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,
+ocf_error_t ocf_promotion_set_param(ocf_cache_t cache, uint8_t param_id,
-		uint8_t param_id, uint32_t param_value);
+		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,
+ocf_error_t ocf_promotion_get_param(ocf_cache_t cache, uint8_t param_id,
-		uint8_t param_id, uint32_t *param_value);
+		ocf_promotion_t type, uint32_t *param_value);
 
 /**
  * @brief Update promotion policy after cache lines have been promoted to cache

tests/functional/pyocf/types/cache.py

@@ -171,8 +171,7 @@ class Cache:
             _metadata_layout=metadata_layout,
             _metadata_volatile=metadata_volatile,
             _backfill=Backfill(
-                _max_queue_size=max_queue_size,
+                _max_queue_size=max_queue_size, _queue_unblock_size=queue_unblock_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(
+    def start_cache(self, default_io_queue: Queue = None, mngt_queue: Queue = None):
-        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.mngt_queue = mngt_queue or Queue(self, "mgmt-{}".format(self.get_name()))
-            self, "mgmt-{}".format(self.get_name())
-        )
 
         if default_io_queue:
             self.io_queues += [default_io_queue]
         else:
-            self.io_queues += [
+            self.io_queues += [Queue(self, "default-io-{}".format(self.get_name()))]
-                Queue(self, "default-io-{}".format(self.get_name()))
-            ]
 
-        status = self.owner.lib.ocf_mngt_cache_set_mngt_queue(
+        status = self.owner.lib.ocf_mngt_cache_set_mngt_queue(self, self.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(
+        status = self.owner.lib.ocf_mngt_cache_set_mode(self.cache_handle, cache_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")),
+                    create_string_buffer(self.device_name.encode("ascii")), c_char_p
-                    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(
+        c = OcfCompletion([("cache", c_void_p), ("priv", c_void_p), ("error", c_int)])
-            [("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(
+        c = OcfCompletion([("cache", c_void_p), ("priv", c_void_p), ("error", c_int)])
-            [("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(
+        c = OcfCompletion([("cache", c_void_p), ("priv", c_void_p), ("error", c_int)])
-            [("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(
+        c = OcfCompletion([("cache", c_void_p), ("priv", c_void_p), ("error", c_int)])
-            [("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(
+        status = self.owner.lib.ocf_cache_get_info(self.cache_handle, byref(cache_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,
+            self.cache_handle, byref(usage), byref(req), byref(block), byref(errors)
-            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(
+                    "dirty": CacheLines(cache_info.inactive.dirty.value, line_size),
-                        cache_info.inactive.dirty.value, line_size
+                    "clean": CacheLines(cache_info.inactive.clean.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(
+        c = OcfCompletion([("cache", c_void_p), ("priv", c_void_p), ("error", c_int)])
-            [("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(
+        c = OcfCompletion([("cache", c_void_p), ("priv", c_void_p), ("error", c_int)])
-            [("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(
+        c = OcfCompletion([("cache", c_void_p), ("priv", c_void_p), ("error", c_int)])
-            [("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()

tests/functional/tests/engine/test_pp.py

@@ -7,11 +7,7 @@ from ctypes import c_int
 import pytest
 import math
 
-from pyocf.types.cache import (
+from pyocf.types.cache import Cache, PromotionPolicy, NhitParams
-    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(),
+            cache.get_default_queue(), i * 4096, write_data.size, IoDir.WRITE, 0, 0
-            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[
+        assert not c.results["error"], "No IO's should fail when turning NHIT policy on"
-            "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(),
+            cache.get_default_queue(), i * 4096, write_data.size, IoDir.WRITE, 0, 0
-            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(
+        write_data = Data(Size.from_B(bytes_to_fill % max_io_size, sector_aligned=True))
-            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 = Cache.start_on_device(cache_device, promotion_policy=PromotionPolicy.NHIT)
-        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(
+    io = core.new_io(cache.get_default_queue(), 0, write_data.size, IoDir.READ, 0, 0)
-        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(
-    cache.set_promotion_policy_param(NhitParams.INSERTION_THRESHOLD, 100)
+        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(
+    io = core.new_io(cache.get_default_queue(), 0, write_data.size, IoDir.WRITE, 0, 0)
-        cache.get_default_queue(), 0, write_data.size, IoDir.WRITE, 0, 0
-    )
     io.set_data(write_data)
     io.callback = comp.callback
     io.submit()