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

Only request evict size equal to request unmapped count

Browse Source 
Removing the logic for oportunistic partition overflow
reduction by evicting more cachelines than actually
required by the request being serviced.

Signed-off-by: Adam Rutkowski <adam.j.rutkowski@intel.com>
This commit is contained in:
Adam Rutkowski 2021-02-02 15:24:20 +01:00
parent 3a7b55c4c2
commit 5538a5a95d
6 changed files with 67 additions and 664 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
src/engine/engine_common.c
View File

@ -430,55 +430,50 @@ static inline int ocf_prepare_clines_miss(struct ocf_request *req,
{ {
int lock_status = -OCF_ERR_NO_LOCK; int lock_status = -OCF_ERR_NO_LOCK;
struct ocf_metadata_lock *metadata_lock = &req->cache->metadata.lock; struct ocf_metadata_lock *metadata_lock = &req->cache->metadata.lock;
uint32_t clines_to_evict = 0;
int res; /* requests to disabled partitions go in pass-through */
if (!ocf_part_is_enabled(&req->cache->user_parts[req->part_id])) {
ocf_req_set_mapping_error(req);
ocf_req_hash_unlock_rd(req);
return lock_status;
}
if (!ocf_part_has_space(req)) {
ocf_req_hash_unlock_rd(req);
goto eviction;
}
/* Mapping must be performed holding (at least) hash-bucket write lock */ /* Mapping must be performed holding (at least) hash-bucket write lock */
ocf_req_hash_lock_upgrade(req); ocf_req_hash_lock_upgrade(req);
/* Verify whether partition occupancy threshold is not reached yet or cache ocf_engine_map(req);
* is not out of free cachelines */
res = ocf_part_check_space(req, &clines_to_evict);
if (res == OCF_PART_IS_DISABLED) {
ocf_req_set_mapping_error(req);
ocf_req_hash_unlock_wr(req);
return lock_status;
}
if (res == OCF_PART_HAS_SPACE) {
ocf_engine_map(req);
if (ocf_req_test_mapping_error(req)) {
goto eviction;
}
if (!ocf_req_test_mapping_error(req)) {
lock_status = lock_clines(req, engine_cbs); lock_status = lock_clines(req, engine_cbs);
if (lock_status < 0) { if (lock_status < 0) {
/* Mapping succeeded, but we failed to acquire cacheline lock. /* Mapping succeeded, but we failed to acquire cacheline lock.
* Don't try to evict, just return error to caller */ * Don't try to evict, just return error to caller */
ocf_req_set_mapping_error(req); ocf_req_set_mapping_error(req);
} }
ocf_req_hash_unlock_wr(req); ocf_req_hash_unlock_wr(req);
return lock_status; return lock_status;
} }
eviction:
ocf_req_hash_unlock_wr(req); ocf_req_hash_unlock_wr(req);
eviction:
ocf_metadata_start_exclusive_access(metadata_lock); ocf_metadata_start_exclusive_access(metadata_lock);
ocf_part_check_space(req, &clines_to_evict); /* repeat traversation to pick up latest metadata status */
ocf_engine_traverse(req);
if (space_managment_evict_do(req->cache, req, clines_to_evict) == if (!ocf_part_has_space(req))
LOOKUP_MISS) { ocf_req_set_part_evict(req);
ocf_req_set_mapping_error(req); else
goto unlock; ocf_req_clear_part_evict(req);
}
if (!ocf_part_is_enabled(&req->cache->user_parts[req->part_id])) { if (space_managment_evict_do(req->cache, req,
/* Partition is disabled but it had cachelines assigned. Now, that they ocf_engine_unmapped_count(req)) == LOOKUP_MISS) {
* are evicted, don't try to map cachelines - we don't want to insert
* new cachelines - the request should be submited in pass through mode
* instead */
ocf_req_set_mapping_error(req); ocf_req_set_mapping_error(req);
goto unlock; goto unlock;
} }

8
src/engine/engine_fast.c
View File

@ -108,7 +108,7 @@ int ocf_read_fast(struct ocf_request *req)
{ {
bool hit; bool hit;
int lock = OCF_LOCK_NOT_ACQUIRED; int lock = OCF_LOCK_NOT_ACQUIRED;
bool part_has_space = false; bool part_has_space;
/* Get OCF request - increase reference counter */ /* Get OCF request - increase reference counter */
ocf_req_get(req); ocf_req_get(req);
@ -126,8 +126,7 @@ int ocf_read_fast(struct ocf_request *req)
hit = ocf_engine_is_hit(req); hit = ocf_engine_is_hit(req);
if (ocf_part_check_space(req, NULL) == OCF_PART_HAS_SPACE) part_has_space = ocf_part_has_space(req);
part_has_space = true;
if (hit && part_has_space) { if (hit && part_has_space) {
ocf_io_start(&req->ioi.io); ocf_io_start(&req->ioi.io);
@ -197,8 +196,7 @@ int ocf_write_fast(struct ocf_request *req)
mapped = ocf_engine_is_mapped(req); mapped = ocf_engine_is_mapped(req);
if (ocf_part_check_space(req, NULL) == OCF_PART_HAS_SPACE) part_has_space = ocf_part_has_space(req);
part_has_space = true;
if (mapped && part_has_space) { if (mapped && part_has_space) {
ocf_io_start(&req->ioi.io); ocf_io_start(&req->ioi.io);

79
src/utils/utils_part.c
View File

@ -190,82 +190,3 @@ void ocf_part_set_valid(struct ocf_cache *cache, ocf_part_id_t id,
} }
} }
} }
static inline uint32_t ocf_part_evict_size(struct ocf_request *req)
{
uint32_t needed_cache_lines, part_available, cache_lines_to_evict;
uint32_t part_occupancy, part_occupancy_debt;
struct ocf_user_part *target_part = &req->cache->user_parts[req->part_id];
uint32_t part_occupancy_limit =
ocf_part_get_max_size(req->cache, target_part);
needed_cache_lines = ocf_engine_repart_count(req) +
ocf_engine_unmapped_count(req);
part_occupancy = ocf_part_get_occupancy(target_part);
if (part_occupancy_limit >= part_occupancy) {
part_available = part_occupancy_limit - part_occupancy;
part_occupancy_debt = 0;
} else {
/* Occupancy is greater than occupancy limit. Evict missing number of
* cachelines, but no more than single eviction limit */
part_occupancy_debt = min((uint32_t)OCF_PENDING_EVICTION_LIMIT,
part_occupancy - part_occupancy_limit);
part_available = 0;
}
if (ocf_freelist_num_free(req->cache->freelist) <
ocf_engine_unmapped_count(req)) {
/* Number of cachelines to insert greater than number of free
* cachelines */
if (part_available >= needed_cache_lines) {
/* Cache is full, but target's part occupancy limit is not reached
*/
ocf_req_clear_part_evict(req);
cache_lines_to_evict = needed_cache_lines;
} else {
/* Cache is full and target part reached it's occupancy limit */
ocf_req_set_part_evict(req);
cache_lines_to_evict = needed_cache_lines - part_available;
}
} else if (part_available < needed_cache_lines) {
/* Enough of free cache lines, but partition reached it's occupancy
* limit */
cache_lines_to_evict = needed_cache_lines - part_available;
ocf_req_set_part_evict(req);
} else if (part_available >= needed_cache_lines) {
/* Enough free cachelines available and they can be assigned to target
* partition */
cache_lines_to_evict = 0;
}
return cache_lines_to_evict + part_occupancy_debt;
}
uint32_t ocf_part_check_space(struct ocf_request *req, uint32_t *to_evict)
{
uint32_t ret = OCF_PART_IS_FULL;
uint32_t _to_evict;
struct ocf_user_part *target_part = &req->cache->user_parts[req->part_id];
if (!ocf_part_is_enabled(target_part) &&
ocf_part_get_occupancy(target_part) == 0) {
/* If partition is disabled, but has assigned cachelines, eviction has
* to be triggered */
return OCF_PART_IS_DISABLED;
}
_to_evict = ocf_part_evict_size(req);
if (_to_evict == 0)
ret = OCF_PART_HAS_SPACE;
if (to_evict)
*to_evict = _to_evict;
return ret;
}

37
src/utils/utils_part.h
View File

@ -100,20 +100,29 @@ static inline bool ocf_part_is_enabled(struct ocf_user_part *part)
return part->config->max_size != 0; return part->config->max_size != 0;
} }
#define OCF_PART_HAS_SPACE 0 static inline uint32_t ocf_part_overflow_size(struct ocf_cache *cache,
#define OCF_PART_IS_FULL 1 struct ocf_user_part *part)
#define OCF_PART_IS_DISABLED 2 {
/** uint32_t part_occupancy = ocf_part_get_occupancy(part);
* Check whether there is enough free cachelines to serve request. If partition uint32_t part_occupancy_limit = ocf_part_get_max_size(cache, part);
* occupancy limit is reached, `req->part_evict` is set to true. Otherwise
* flag is set to false and eviction from any partition should be triggered. if (part_occupancy > part_occupancy_limit)
* return part_occupancy - part_occupancy_limit;
* @return
* OCF_PART_HAS_SPACE when cachelines alloted successfully return 0;
* OCF_PART_IS_FULL when need to evict some cachelines to serve request }
* OCF_PART_IS_DISABLED when caching for particular partition is disabled
*/ static inline bool ocf_part_has_space(struct ocf_request *req)
uint32_t ocf_part_check_space(struct ocf_request *req, uint32_t *to_evict); {
struct ocf_user_part *target_part = &req->cache->user_parts[req->part_id];
uint64_t part_occupancy_limit =
ocf_part_get_max_size(req->cache, target_part);
uint64_t needed_cache_lines = ocf_engine_repart_count(req) +
ocf_engine_unmapped_count(req);
uint64_t part_occupancy = ocf_part_get_occupancy(target_part);
return (part_occupancy + needed_cache_lines <= part_occupancy_limit);
}
static inline ocf_cache_mode_t ocf_part_get_cache_mode(ocf_cache_t cache, static inline ocf_cache_mode_t ocf_part_get_cache_mode(ocf_cache_t cache,
ocf_part_id_t part_id) ocf_part_id_t part_id)

38
tests/unit/tests/engine/engine_common.c/prepare_clines_miss.c
View File

@ -44,8 +44,7 @@ void __wrap_ocf_req_hash_unlock_wr(struct ocf_request *req)
{ {
} }
uint32_t __wrap_ocf_part_check_space(struct ocf_request *req, uint32_t __wrap_ocf_part_has_space(struct ocf_request *req)
uint32_t *to_evict)
{ {
return mock(); return mock();
} }
@ -98,7 +97,7 @@ static void ocf_prepare_clines_miss_test01(void **state)
{ {
struct ocf_request req = {}; struct ocf_request req = {};
print_test_description("Target part is disabled and empty\n"); print_test_description("Target part is disabled and empty\n");
will_return(__wrap_ocf_part_check_space, OCF_PART_IS_DISABLED); will_return(__wrap_ocf_part_is_enabled, false);
expect_function_call(__wrap_ocf_req_set_mapping_error); expect_function_call(__wrap_ocf_req_set_mapping_error);
assert_int_equal(ocf_prepare_clines_miss(&req, NULL), -OCF_ERR_NO_LOCK); assert_int_equal(ocf_prepare_clines_miss(&req, NULL), -OCF_ERR_NO_LOCK);
} }
@ -107,13 +106,8 @@ static void ocf_prepare_clines_miss_test02(void **state)
{ {
struct ocf_request req = {}; struct ocf_request req = {};
print_test_description("Target part is disabled but has cachelines assigned.\n"); print_test_description("Target part is disabled but has cachelines assigned.\n");
print_test_description("\tTrigger eviction and mark mapping error\n"); print_test_description("\tMark mapping error\n");
will_return(__wrap_ocf_part_check_space, OCF_PART_IS_FULL);
will_return(__wrap_ocf_part_check_space, OCF_PART_IS_FULL);
expect_function_call(__wrap_space_managment_evict_do);
will_return(__wrap_space_managment_evict_do, LOOKUP_MAPPED);
will_return(__wrap_ocf_part_is_enabled, false); will_return(__wrap_ocf_part_is_enabled, false);
expect_function_call(__wrap_ocf_req_set_mapping_error); expect_function_call(__wrap_ocf_req_set_mapping_error);
@ -126,12 +120,12 @@ static void ocf_prepare_clines_miss_test03(void **state)
print_test_description("Target part is enabled but doesn't have enough space.\n"); print_test_description("Target part is enabled but doesn't have enough space.\n");
print_test_description("\tEviction is ok and cachelines lock is acquired.\n"); print_test_description("\tEviction is ok and cachelines lock is acquired.\n");
will_return(__wrap_ocf_part_check_space, OCF_PART_IS_FULL); will_return(__wrap_ocf_part_is_enabled, true);
will_return(__wrap_ocf_part_check_space, OCF_PART_IS_FULL); will_return(__wrap_ocf_part_has_space, false);
will_return(__wrap_ocf_part_has_space, false);
expect_function_call(__wrap_space_managment_evict_do); expect_function_call(__wrap_space_managment_evict_do);
will_return(__wrap_space_managment_evict_do, LOOKUP_MAPPED); will_return(__wrap_space_managment_evict_do, LOOKUP_MAPPED);
will_return(__wrap_ocf_part_is_enabled, true);
expect_function_call(__wrap_ocf_engine_map); expect_function_call(__wrap_ocf_engine_map);
@ -149,9 +143,10 @@ static void ocf_prepare_clines_miss_test04(void **state)
print_test_description("Target part is enabled but doesn't have enough space.\n"); print_test_description("Target part is enabled but doesn't have enough space.\n");
print_test_description("\tEviction failed\n"); print_test_description("\tEviction failed\n");
will_return(__wrap_ocf_part_check_space, OCF_PART_IS_FULL); will_return(__wrap_ocf_part_is_enabled, true);
will_return(__wrap_ocf_part_check_space, OCF_PART_IS_FULL); will_return(__wrap_ocf_part_has_space, false);
will_return(__wrap_ocf_part_has_space, false);
expect_function_call(__wrap_space_managment_evict_do); expect_function_call(__wrap_space_managment_evict_do);
will_return(__wrap_space_managment_evict_do, LOOKUP_MISS); will_return(__wrap_space_managment_evict_do, LOOKUP_MISS);
expect_function_call(__wrap_ocf_req_set_mapping_error); expect_function_call(__wrap_ocf_req_set_mapping_error);
@ -165,8 +160,8 @@ static void ocf_prepare_clines_miss_test05(void **state)
print_test_description("Target part is enabled but doesn't have enough space.\n"); print_test_description("Target part is enabled but doesn't have enough space.\n");
print_test_description("Eviction is ok, but mapping failed.\n"); print_test_description("Eviction is ok, but mapping failed.\n");
will_return(__wrap_ocf_part_check_space, OCF_PART_IS_FULL); will_return(__wrap_ocf_part_has_space, false);
will_return(__wrap_ocf_part_check_space, OCF_PART_IS_FULL); will_return(__wrap_ocf_part_has_space, false);
expect_function_call(__wrap_space_managment_evict_do); expect_function_call(__wrap_space_managment_evict_do);
will_return(__wrap_space_managment_evict_do, LOOKUP_HIT); will_return(__wrap_space_managment_evict_do, LOOKUP_HIT);
@ -185,8 +180,8 @@ static void ocf_prepare_clines_miss_test06(void **state)
print_test_description("Target part is enabled but doesn't have enough space.\n"); print_test_description("Target part is enabled but doesn't have enough space.\n");
print_test_description("Eviction and mapping were ok, but failed to lock cachelines.\n"); print_test_description("Eviction and mapping were ok, but failed to lock cachelines.\n");
will_return(__wrap_ocf_part_check_space, OCF_PART_IS_FULL); will_return(__wrap_ocf_part_has_space, false);
will_return(__wrap_ocf_part_check_space, OCF_PART_IS_FULL); will_return(__wrap_ocf_part_has_space, false);
expect_function_call(__wrap_space_managment_evict_do); expect_function_call(__wrap_space_managment_evict_do);
will_return(__wrap_space_managment_evict_do, LOOKUP_HIT); will_return(__wrap_space_managment_evict_do, LOOKUP_HIT);
@ -210,8 +205,8 @@ static void ocf_prepare_clines_miss_test07(void **state)
print_test_description("Target part is enabled but doesn't have enough space.\n"); print_test_description("Target part is enabled but doesn't have enough space.\n");
print_test_description("Eviction and mapping were ok, lock not acquired.\n"); print_test_description("Eviction and mapping were ok, lock not acquired.\n");
will_return(__wrap_ocf_part_check_space, OCF_PART_IS_FULL); will_return(__wrap_ocf_part_has_space, false);
will_return(__wrap_ocf_part_check_space, OCF_PART_IS_FULL); will_return(__wrap_ocf_part_has_space, false);
expect_function_call(__wrap_space_managment_evict_do); expect_function_call(__wrap_space_managment_evict_do);
will_return(__wrap_space_managment_evict_do, LOOKUP_HIT); will_return(__wrap_space_managment_evict_do, LOOKUP_HIT);
@ -233,7 +228,8 @@ static void ocf_prepare_clines_miss_test08(void **state)
print_test_description("Target part is enabled has enough space.\n"); print_test_description("Target part is enabled has enough space.\n");
print_test_description("\tMapping and cacheline lock are both ok\n"); print_test_description("\tMapping and cacheline lock are both ok\n");
will_return(__wrap_ocf_part_check_space, OCF_PART_HAS_SPACE); will_return(__wrap_ocf_part_is_enabled, true);
will_return(__wrap_ocf_part_has_space, true);
expect_function_call(__wrap_ocf_engine_map); expect_function_call(__wrap_ocf_engine_map);
will_return(__wrap_ocf_req_test_mapping_error, false); will_return(__wrap_ocf_req_test_mapping_error, false);

516
tests/unit/tests/utils/utils_part.c/ocf_part_evict_size.c
View File

@ -1,516 +0,0 @@
/*
* <tested_file_path>src/utils/utils_part.c</tested_file_path>
* <tested_function>ocf_part_evict_size</tested_function>
* <functions_to_leave>
* INSERT HERE LIST OF FUNCTIONS YOU WANT TO LEAVE
* ONE FUNCTION PER LINE
* </functions_to_leave>
*/
#undef static
#undef inline
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include "print_desc.h"
#include "ocf/ocf.h"
#include "../ocf_cache_priv.h"
#include "../ocf_request.h"
#include "../metadata/metadata.h"
#include "../engine/cache_engine.h"
#include "../eviction/ops.h"
#include "utils_part.h"
#include "utils/utils_part.c/ocf_part_evict_size_generated_wraps.c"
uint32_t __wrap_ocf_part_get_max_size(ocf_cache_t cache,
struct ocf_user_part *target_part)
{
return mock();
}
uint32_t __wrap_ocf_engine_repart_count(struct ocf_request *req)
{
return mock();
}
uint32_t __wrap_ocf_engine_unmapped_count(struct ocf_request *req)
{
return mock();
}
uint32_t __wrap_ocf_part_get_occupancy(struct ocf_user_part *target_part)
{
return mock();
}
ocf_cache_line_t __wrap_ocf_freelist_num_free(ocf_freelist_t freelist)
{
return mock();
}
void __wrap_ocf_req_set_part_evict(struct ocf_request *req)
{
function_called();
}
void __wrap_ocf_req_clear_part_evict(struct ocf_request *req)
{
function_called();
}
static void ocf_part_evict_size_test01(void **state)
{
uint32_t max_part_size = 1024;
uint32_t cachelines_to_repart = 0;
uint32_t cachelines_to_map = 320;
uint32_t part_occupied_cachelines = 512;
uint32_t freelist_size = 500;
struct ocf_request req;
req.cache = test_malloc(sizeof(struct ocf_cache));
print_test_description("Enough free space available");
will_return(__wrap_ocf_part_get_max_size, max_part_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
will_return(__wrap_ocf_engine_repart_count, cachelines_to_repart);
will_return(__wrap_ocf_part_get_occupancy, part_occupied_cachelines);
// Enough free cachelines to map a whole request
will_return(__wrap_ocf_freelist_num_free, freelist_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
assert_int_equal(ocf_part_evict_size(&req), 0);
test_free(req.cache);
}
static void ocf_part_evict_size_test02(void **state)
{
uint32_t max_part_size = 1024;
uint32_t cachelines_to_repart = 0;
uint32_t cachelines_to_map = 320;
uint32_t part_occupied_cachelines = 960;
uint32_t freelist_size = 500;
struct ocf_request req;
req.cache = test_malloc(sizeof(struct ocf_cache));
uint32_t available_cachelines = max_part_size - part_occupied_cachelines;
uint32_t cachelines_to_evict = cachelines_to_map - available_cachelines;
print_test_description("Cache has enough free cachelines,"
" but target partition must be evicted");
will_return(__wrap_ocf_part_get_max_size, max_part_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
will_return(__wrap_ocf_engine_repart_count, cachelines_to_repart);
will_return(__wrap_ocf_part_get_occupancy, part_occupied_cachelines);
will_return(__wrap_ocf_freelist_num_free, freelist_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
expect_function_call(__wrap_ocf_req_set_part_evict);
assert_int_equal(ocf_part_evict_size(&req), cachelines_to_evict);
test_free(req.cache);
}
static void ocf_part_evict_size_test03(void **state)
{
uint32_t max_part_size = 1024;
uint32_t cachelines_to_repart = 320;
uint32_t cachelines_to_map = 0;
uint32_t part_occupied_cachelines = 512;
uint32_t freelist_size = 0;
struct ocf_request req;
req.cache = test_malloc(sizeof(struct ocf_cache));
uint32_t cachelines_to_evict = 0;
print_test_description("Only repart (no mapping). Freelist is empty but "
"space in a target part is availabe,");
print_test_description("\tso no cachelines should be "
" evcited from cache");
will_return(__wrap_ocf_part_get_max_size, max_part_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
will_return(__wrap_ocf_engine_repart_count, cachelines_to_repart);
will_return(__wrap_ocf_part_get_occupancy, part_occupied_cachelines);
will_return(__wrap_ocf_freelist_num_free, freelist_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
assert_int_equal(ocf_part_evict_size(&req), cachelines_to_evict);
test_free(req.cache);
}
static void ocf_part_evict_size_test04(void **state)
{
uint32_t max_part_size = 1024;
uint32_t cachelines_to_repart = 320;
uint32_t cachelines_to_map = 0;
uint32_t part_occupied_cachelines = 1100;
uint32_t freelist_size = 0;
struct ocf_request req;
req.cache = test_malloc(sizeof(struct ocf_cache));
uint32_t cachelines_debt = part_occupied_cachelines - max_part_size;
uint32_t cachelines_to_evict = cachelines_to_repart + cachelines_debt;
print_test_description("Only repart (no mapping). Freelist is empty and no"
" space in target part is availabe.");
print_test_description("\tEvict only from target partition");
will_return(__wrap_ocf_part_get_max_size, max_part_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
will_return(__wrap_ocf_engine_repart_count, cachelines_to_repart);
will_return(__wrap_ocf_part_get_occupancy, part_occupied_cachelines);
will_return(__wrap_ocf_freelist_num_free, freelist_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
expect_function_call(__wrap_ocf_req_set_part_evict);
assert_int_equal(ocf_part_evict_size(&req), cachelines_to_evict);
test_free(req.cache);
}
static void ocf_part_evict_size_test05(void **state)
{
uint32_t max_part_size = 1024;
uint32_t cachelines_to_repart = 0;
uint32_t cachelines_to_map = 320;
uint32_t part_occupied_cachelines = 960;
uint32_t freelist_size = 0;
struct ocf_request req;
req.cache = test_malloc(sizeof(struct ocf_cache));
uint32_t available_cachelines = max_part_size - part_occupied_cachelines;
uint32_t cachelines_to_evict = cachelines_to_map - available_cachelines;
print_test_description("Freelist is empty and no space in the target part "
"is available");
will_return(__wrap_ocf_part_get_max_size, max_part_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
will_return(__wrap_ocf_engine_repart_count, cachelines_to_repart);
will_return(__wrap_ocf_part_get_occupancy, part_occupied_cachelines);
will_return(__wrap_ocf_freelist_num_free, freelist_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
expect_function_call(__wrap_ocf_req_set_part_evict);
assert_int_equal(ocf_part_evict_size(&req), cachelines_to_evict);
test_free(req.cache);
}
static void ocf_part_evict_size_test06(void **state)
{
uint32_t max_part_size = 1024;
uint32_t cachelines_to_repart = 0;
uint32_t cachelines_to_map = 320;
uint32_t part_occupied_cachelines = 320;
uint32_t freelist_size = 0;
struct ocf_request req;
req.cache = test_malloc(sizeof(struct ocf_cache));
uint32_t available_cachelines = max_part_size - part_occupied_cachelines;
uint32_t cachelines_to_evict = cachelines_to_map;
print_test_description("Freelist is empty but target part has enough space");
will_return(__wrap_ocf_part_get_max_size, max_part_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
will_return(__wrap_ocf_engine_repart_count, cachelines_to_repart);
will_return(__wrap_ocf_part_get_occupancy, part_occupied_cachelines);
will_return(__wrap_ocf_freelist_num_free, freelist_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
expect_function_call(__wrap_ocf_req_clear_part_evict);
assert_int_equal(ocf_part_evict_size(&req), cachelines_to_evict);
test_free(req.cache);
}
static void ocf_part_evict_size_test07(void **state)
{
uint32_t max_part_size = 1024;
uint32_t cachelines_to_repart = 0;
uint32_t cachelines_to_map = 320;
uint32_t part_occupied_cachelines = 1280;
uint32_t freelist_size = 0;
struct ocf_request req;
req.cache = test_malloc(sizeof(struct ocf_cache));
uint32_t debt_cachelines = part_occupied_cachelines - max_part_size;
uint32_t cachelines_to_evict = cachelines_to_map + debt_cachelines;
print_test_description("Freelist is empty and part occupancy exceeded");
will_return(__wrap_ocf_part_get_max_size, max_part_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
will_return(__wrap_ocf_engine_repart_count, cachelines_to_repart);
will_return(__wrap_ocf_part_get_occupancy, part_occupied_cachelines);
will_return(__wrap_ocf_freelist_num_free, freelist_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
expect_function_call(__wrap_ocf_req_set_part_evict);
assert_int_equal(ocf_part_evict_size(&req),
(part_occupied_cachelines - max_part_size) + cachelines_to_map);
test_free(req.cache);
}
static void ocf_part_evict_size_test08(void **state)
{
uint32_t max_part_size = 1024;
uint32_t cachelines_to_repart = 320;
uint32_t cachelines_to_map = 0;
uint32_t part_occupied_cachelines = 1280;
uint32_t freelist_size = 0;
struct ocf_request req;
req.cache = test_malloc(sizeof(struct ocf_cache));
uint32_t debt_cachelines = part_occupied_cachelines - max_part_size;
uint32_t cachelines_to_evict = debt_cachelines + cachelines_to_repart;
print_test_description("Target part occupancy limit is exceeded during "
"repart");
will_return(__wrap_ocf_part_get_max_size, max_part_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
will_return(__wrap_ocf_engine_repart_count, cachelines_to_repart);
will_return(__wrap_ocf_part_get_occupancy, part_occupied_cachelines);
will_return(__wrap_ocf_freelist_num_free, freelist_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
expect_function_call(__wrap_ocf_req_set_part_evict);
assert_int_equal(ocf_part_evict_size(&req),
(part_occupied_cachelines - max_part_size) + cachelines_to_repart);
test_free(req.cache);
}
static void ocf_part_evict_size_test09(void **state)
{
uint32_t max_part_size = 1024;
uint32_t cachelines_to_repart = 320;
uint32_t cachelines_to_map = 0;
uint32_t part_occupied_cachelines = 320;
uint32_t freelist_size = 0;
struct ocf_request req;
req.cache = test_malloc(sizeof(struct ocf_cache));
uint32_t cachelines_to_evict = 0;
print_test_description("Repart while target part has enough of available "
"space");
will_return(__wrap_ocf_part_get_max_size, max_part_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
will_return(__wrap_ocf_engine_repart_count, cachelines_to_repart);
will_return(__wrap_ocf_part_get_occupancy, part_occupied_cachelines);
will_return(__wrap_ocf_freelist_num_free, freelist_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
assert_int_equal(ocf_part_evict_size(&req), cachelines_to_evict);
test_free(req.cache);
}
static void ocf_part_evict_size_test10(void **state)
{
uint32_t max_part_size = 1024;
uint32_t cachelines_to_repart = 0;
uint32_t cachelines_to_map = 320;
uint32_t part_occupied_cachelines = 320;
uint32_t freelist_size = 320;
struct ocf_request req;
req.cache = test_malloc(sizeof(struct ocf_cache));
uint32_t cachelines_to_evict = 0;
print_test_description("Enough of available cachelines in target part, "
"freelist has exactly required number of free cachelines");
will_return(__wrap_ocf_part_get_max_size, max_part_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
will_return(__wrap_ocf_engine_repart_count, cachelines_to_repart);
will_return(__wrap_ocf_part_get_occupancy, part_occupied_cachelines);
will_return(__wrap_ocf_freelist_num_free, freelist_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
assert_int_equal(ocf_part_evict_size(&req), cachelines_to_evict);
test_free(req.cache);
}
static void ocf_part_evict_size_test11(void **state)
{
uint32_t max_part_size = 1024;
uint32_t cachelines_to_repart = 320;
uint32_t cachelines_to_map = 0;
uint32_t part_occupied_cachelines = 384;
uint32_t freelist_size = 0;
struct ocf_request req;
req.cache = test_malloc(sizeof(struct ocf_cache));
uint32_t cachelines_to_evict = 0;
print_test_description("Number of cachelines to repart is equal to number "
"of cachelines available in the target partition");
will_return(__wrap_ocf_part_get_max_size, max_part_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
will_return(__wrap_ocf_engine_repart_count, cachelines_to_repart);
will_return(__wrap_ocf_part_get_occupancy, part_occupied_cachelines);
will_return(__wrap_ocf_freelist_num_free, freelist_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
assert_int_equal(ocf_part_evict_size(&req), cachelines_to_evict);
test_free(req.cache);
}
static void ocf_part_evict_size_test12(void **state)
{
uint32_t max_part_size = 0;
uint32_t cachelines_to_repart = 0;
uint32_t cachelines_to_map = 320;
uint32_t part_occupied_cachelines = 384;
uint32_t freelist_size = 0;
struct ocf_request req;
req.cache = test_malloc(sizeof(struct ocf_cache));
uint32_t cachelines_to_evict =
part_occupied_cachelines + cachelines_to_map;
print_test_description("Freelist IS empty. Max occupancy set to 0, but "
"some cachelines are still assigned to traget part - evict them");
will_return(__wrap_ocf_part_get_max_size, max_part_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
will_return(__wrap_ocf_engine_repart_count, cachelines_to_repart);
will_return(__wrap_ocf_part_get_occupancy, part_occupied_cachelines);
will_return(__wrap_ocf_freelist_num_free, freelist_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
expect_function_call(__wrap_ocf_req_set_part_evict);
assert_true(ocf_part_evict_size(&req) >= part_occupied_cachelines);
test_free(req.cache);
}
static void ocf_part_evict_size_test13(void **state)
{
uint32_t max_part_size = 0;
uint32_t cachelines_to_repart = 0;
uint32_t cachelines_to_map = 320;
uint32_t part_occupied_cachelines = 384;
uint32_t freelist_size = 1024;
struct ocf_request req;
req.cache = test_malloc(sizeof(struct ocf_cache));
uint32_t cachelines_to_evict =
part_occupied_cachelines + cachelines_to_map;
print_test_description("Freelist IS NOT empty. Max occupancy set to 0, but"
" some cachelines are still assigned to traget part - evict them");
will_return(__wrap_ocf_part_get_max_size, max_part_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
will_return(__wrap_ocf_engine_repart_count, cachelines_to_repart);
will_return(__wrap_ocf_part_get_occupancy, part_occupied_cachelines);
will_return(__wrap_ocf_freelist_num_free, freelist_size);
will_return(__wrap_ocf_engine_unmapped_count, cachelines_to_map);
expect_function_call(__wrap_ocf_req_set_part_evict);
assert_true(ocf_part_evict_size(&req) >= part_occupied_cachelines);
test_free(req.cache);
}
int main(void)
{
const struct CMUnitTest tests[] = {
cmocka_unit_test(ocf_part_evict_size_test01),
cmocka_unit_test(ocf_part_evict_size_test02),
cmocka_unit_test(ocf_part_evict_size_test03),
cmocka_unit_test(ocf_part_evict_size_test04),
cmocka_unit_test(ocf_part_evict_size_test05),
cmocka_unit_test(ocf_part_evict_size_test06),
cmocka_unit_test(ocf_part_evict_size_test07),
cmocka_unit_test(ocf_part_evict_size_test08),
cmocka_unit_test(ocf_part_evict_size_test09),
cmocka_unit_test(ocf_part_evict_size_test10),
cmocka_unit_test(ocf_part_evict_size_test11),
cmocka_unit_test(ocf_part_evict_size_test12),
cmocka_unit_test(ocf_part_evict_size_test13)
};
print_message("Unit test for ocf_part_evict_size\n");
return cmocka_run_group_tests(tests, NULL, NULL);
}