diff --git a/src/engine/engine_common.c b/src/engine/engine_common.c index 7da86e3..8fa878f 100644 --- a/src/engine/engine_common.c +++ b/src/engine/engine_common.c @@ -202,7 +202,7 @@ static void ocf_engine_set_hot(struct ocf_request *req) if (status == LOOKUP_HIT) { /* Update eviction (LRU) */ - evp_lru_hot_cline(cache, entry->coll_idx); + ocf_lru_hot_cline(cache, entry->coll_idx); } } } @@ -518,7 +518,7 @@ int ocf_engine_prepare_clines(struct ocf_request *req) ocf_hb_req_prot_unlock_wr(req); if (ocf_req_is_cleaning_required(req)) { - evp_lru_clean(req->cache, user_part, req->io_queue, + ocf_lru_clean(req->cache, user_part, req->io_queue, 128); } diff --git a/src/metadata/metadata.c b/src/metadata/metadata.c index 8b63b76..9e89962 100644 --- a/src/metadata/metadata.c +++ b/src/metadata/metadata.c @@ -1167,9 +1167,9 @@ static void _recovery_rebuild_cline_metadata(ocf_cache_t cache, ocf_metadata_add_to_collision(cache, core_id, core_line, hash_index, cache_line); - evp_lru_init_cline(cache, cache_line); + ocf_lru_init_cline(cache, cache_line); - evp_lru_hot_cline(cache, cache_line); + ocf_lru_hot_cline(cache, cache_line); env_atomic_inc(&core->runtime_meta->cached_clines); env_atomic_inc(&core->runtime_meta-> diff --git a/src/mngt/ocf_mngt_cache.c b/src/mngt/ocf_mngt_cache.c index 2a2fee9..995e546 100644 --- a/src/mngt/ocf_mngt_cache.c +++ b/src/mngt/ocf_mngt_cache.c @@ -185,9 +185,9 @@ static void __init_parts_attached(ocf_cache_t cache) ocf_part_id_t part_id; for (part_id = 0; part_id < OCF_USER_IO_CLASS_MAX; part_id++) - evp_lru_init_evp(cache, &cache->user_parts[part_id].part); + ocf_lru_init_evp(cache, &cache->user_parts[part_id].part); - evp_lru_init_evp(cache, &cache->free); + ocf_lru_init_evp(cache, &cache->free); } static void __init_free(ocf_cache_t cache) diff --git a/src/ocf_lru.c b/src/ocf_lru.c index 9bbe7df..260bf7a 100644 --- a/src/ocf_lru.c +++ b/src/ocf_lru.c @@ -220,7 +220,7 @@ static void balance_lru_list(ocf_cache_t cache, /*-- End of LRU functions*/ -void evp_lru_init_cline(ocf_cache_t cache, ocf_cache_line_t cline) +void ocf_lru_init_cline(ocf_cache_t cache, ocf_cache_line_t cline) { struct ocf_lru_meta *node; @@ -231,7 +231,7 @@ void evp_lru_init_cline(ocf_cache_t cache, ocf_cache_line_t cline) node->next = end_marker; } -static struct ocf_lru_list *evp_lru_get_list(struct ocf_part *part, +static struct ocf_lru_list *ocf_lru_get_list(struct ocf_part *part, uint32_t evp, bool clean) { return clean ? &part->runtime->lru[evp].clean : @@ -250,11 +250,11 @@ static inline struct ocf_lru_list *evp_get_cline_list(ocf_cache_t cache, ENV_BUG_ON(part_id > OCF_USER_IO_CLASS_MAX); part = &cache->user_parts[part_id].part; - return evp_lru_get_list(part, ev_list, + return ocf_lru_get_list(part, ev_list, !metadata_test_dirty(cache, cline)); } -static void evp_lru_move(ocf_cache_t cache, ocf_cache_line_t cline, +static void ocf_lru_move(ocf_cache_t cache, ocf_cache_line_t cline, struct ocf_part *src_part, struct ocf_lru_list *src_list, struct ocf_part *dst_part, struct ocf_lru_list *dst_list) { @@ -269,7 +269,7 @@ static void evp_lru_move(ocf_cache_t cache, ocf_cache_line_t cline, } /* the caller must hold the metadata lock */ -void evp_lru_rm_cline(ocf_cache_t cache, ocf_cache_line_t cline) +void ocf_lru_rm_cline(ocf_cache_t cache, ocf_cache_line_t cline) { struct ocf_lru_list *list, *free; uint32_t ev_list = (cline % OCF_NUM_EVICTION_LISTS); @@ -283,13 +283,13 @@ void evp_lru_rm_cline(ocf_cache_t cache, ocf_cache_line_t cline) OCF_METADATA_EVICTION_WR_LOCK(cline); list = evp_get_cline_list(cache, cline); - free = evp_lru_get_list(&cache->free, ev_list, true); - evp_lru_move(cache, cline, part, list, &cache->free, free); + free = ocf_lru_get_list(&cache->free, ev_list, true); + ocf_lru_move(cache, cline, part, list, &cache->free, free); OCF_METADATA_EVICTION_WR_UNLOCK(cline); } -static void evp_lru_repart_locked(ocf_cache_t cache, ocf_cache_line_t cline, +static void ocf_lru_repart_locked(ocf_cache_t cache, ocf_cache_line_t cline, struct ocf_part *src_part, struct ocf_part *dst_part) { uint32_t ev_list = (cline % OCF_NUM_EVICTION_LISTS); @@ -297,17 +297,17 @@ static void evp_lru_repart_locked(ocf_cache_t cache, ocf_cache_line_t cline, bool clean; clean = !metadata_test_dirty(cache, cline); - src_list = evp_lru_get_list(src_part, ev_list, clean); - dst_list = evp_lru_get_list(dst_part, ev_list, clean); + src_list = ocf_lru_get_list(src_part, ev_list, clean); + dst_list = ocf_lru_get_list(dst_part, ev_list, clean); - evp_lru_move(cache, cline, src_part, src_list, dst_part, dst_list); + ocf_lru_move(cache, cline, src_part, src_list, dst_part, dst_list); } void ocf_lru_repart(ocf_cache_t cache, ocf_cache_line_t cline, struct ocf_part *src_part, struct ocf_part *dst_part) { OCF_METADATA_EVICTION_WR_LOCK(cline); - evp_lru_repart_locked(cache, cline, src_part, dst_part); + ocf_lru_repart_locked(cache, cline, src_part, dst_part); OCF_METADATA_EVICTION_WR_UNLOCK(cline); } @@ -334,7 +334,7 @@ static inline void lru_iter_init(struct ocf_lru_iter *iter, ocf_cache_t cache, iter->req = req; for (i = 0; i < OCF_NUM_EVICTION_LISTS; i++) - iter->curr_cline[i] = evp_lru_get_list(part, i, clean)->tail; + iter->curr_cline[i] = ocf_lru_get_list(part, i, clean)->tail; } static inline void lru_iter_cleaning_init(struct ocf_lru_iter *iter, @@ -350,7 +350,7 @@ static inline void lru_iter_eviction_init(struct ocf_lru_iter *iter, { /* Lock hash buckets for write, cachelines according to user request, * however exclusive cacheline access is needed even in case of read - * access. _evp_lru_evict_hash_locked tells whether given hash bucket + * access. _ocf_lru_evict_hash_locked tells whether given hash bucket * is already locked as part of request hash locking (to avoid attempt * to acquire the same hash bucket lock twice) */ lru_iter_init(iter, cache, part, start_evp, true, ocf_req_hash_in_range, @@ -473,7 +473,7 @@ static inline ocf_cache_line_t lru_iter_eviction_next(struct ocf_lru_iter *iter, ocf_metadata_eviction_wr_lock(&cache->metadata.lock, curr_evp); - list = evp_lru_get_list(part, curr_evp, iter->clean); + list = ocf_lru_get_list(part, curr_evp, iter->clean); cline = list->tail; while (cline != end_marker && !_lru_iter_evition_lock(iter, @@ -483,7 +483,7 @@ static inline ocf_cache_line_t lru_iter_eviction_next(struct ocf_lru_iter *iter, if (cline != end_marker) { if (dst_part != part) { - evp_lru_repart_locked(cache, cline, part, + ocf_lru_repart_locked(cache, cline, part, dst_part); } else { remove_lru_list(cache, list, cline); @@ -526,7 +526,7 @@ static inline ocf_cache_line_t lru_iter_free_next(struct ocf_lru_iter *iter, ocf_metadata_eviction_wr_lock(&cache->metadata.lock, curr_evp); - list = evp_lru_get_list(free, curr_evp, true); + list = ocf_lru_get_list(free, curr_evp, true); cline = list->tail; while (cline != end_marker && !ocf_cache_line_try_lock_wr( @@ -535,7 +535,7 @@ static inline ocf_cache_line_t lru_iter_free_next(struct ocf_lru_iter *iter, } if (cline != end_marker) { - evp_lru_repart_locked(cache, cline, free, dst_part); + ocf_lru_repart_locked(cache, cline, free, dst_part); } ocf_metadata_eviction_wr_unlock(&cache->metadata.lock, @@ -580,7 +580,7 @@ static inline ocf_cache_line_t lru_iter_cleaning_next(struct ocf_lru_iter *iter) return cline; } -static void evp_lru_clean_end(void *private_data, int error) +static void ocf_lru_clean_end(void *private_data, int error) { struct ocf_part_cleaning_ctx *ctx = private_data; unsigned i; @@ -594,7 +594,7 @@ static void evp_lru_clean_end(void *private_data, int error) ocf_refcnt_dec(&ctx->counter); } -static int evp_lru_clean_get(ocf_cache_t cache, void *getter_context, +static int ocf_lru_clean_get(ocf_cache_t cache, void *getter_context, uint32_t idx, ocf_cache_line_t *line) { struct ocf_part_cleaning_ctx *ctx = getter_context; @@ -607,7 +607,7 @@ static int evp_lru_clean_get(ocf_cache_t cache, void *getter_context, return 0; } -void evp_lru_clean(ocf_cache_t cache, struct ocf_user_part *user_part, +void ocf_lru_clean(ocf_cache_t cache, struct ocf_user_part *user_part, ocf_queue_t io_queue, uint32_t count) { struct ocf_part_cleaning_ctx *ctx = &user_part->cleaning; @@ -617,9 +617,9 @@ void evp_lru_clean(ocf_cache_t cache, struct ocf_user_part *user_part, .do_sort = true, .cmpl_context = ctx, - .cmpl_fn = evp_lru_clean_end, + .cmpl_fn = ocf_lru_clean_end, - .getter = evp_lru_clean_get, + .getter = ocf_lru_clean_get, .getter_context = ctx, .count = min(count, OCF_EVICTION_CLEAN_SIZE), @@ -673,7 +673,7 @@ void evp_lru_clean(ocf_cache_t cache, struct ocf_user_part *user_part, ocf_cleaner_fire(cache, &attribs); } -bool evp_lru_can_evict(ocf_cache_t cache) +bool ocf_lru_can_evict(ocf_cache_t cache) { if (env_atomic_read(&cache->pending_eviction_clines) >= OCF_PENDING_EVICTION_LIMIT) { @@ -683,7 +683,7 @@ bool evp_lru_can_evict(ocf_cache_t cache) return true; } -static void evp_lru_invalidate(ocf_cache_t cache, ocf_cache_line_t cline, +static void ocf_lru_invalidate(ocf_cache_t cache, ocf_cache_line_t cline, ocf_core_id_t core_id, ocf_part_id_t part_id) { ocf_core_t core; @@ -711,7 +711,7 @@ static void evp_lru_invalidate(ocf_cache_t cache, ocf_cache_line_t cline, * NOTE: all cachelines assigned to the request in this function are marked * as LOOKUP_REMAPPED and are write locked. */ -uint32_t evp_lru_req_clines(struct ocf_request *req, +uint32_t ocf_lru_req_clines(struct ocf_request *req, struct ocf_part *src_part, uint32_t cline_no) { struct ocf_alock* alock; @@ -746,7 +746,7 @@ uint32_t evp_lru_req_clines(struct ocf_request *req, i = 0; while (i < cline_no) { - if (!evp_lru_can_evict(cache)) + if (!ocf_lru_can_evict(cache)) break; if (src_part->id != PARTITION_FREELIST) { @@ -773,7 +773,7 @@ uint32_t evp_lru_req_clines(struct ocf_request *req, ENV_BUG_ON(req->map[req_idx].status != LOOKUP_MISS); if (src_part->id != PARTITION_FREELIST) { - evp_lru_invalidate(cache, cline, core_id, src_part->id); + ocf_lru_invalidate(cache, cline, core_id, src_part->id); _lru_unlock_hash(&iter, core_id, core_line); } @@ -797,7 +797,7 @@ uint32_t evp_lru_req_clines(struct ocf_request *req, } /* the caller must hold the metadata lock */ -void evp_lru_hot_cline(ocf_cache_t cache, ocf_cache_line_t cline) +void ocf_lru_hot_cline(ocf_cache_t cache, ocf_cache_line_t cline) { struct ocf_lru_meta *node; struct ocf_lru_list *list; @@ -839,15 +839,15 @@ static inline void _lru_init(struct ocf_lru_list *list, bool track_hot) list->track_hot = track_hot; } -void evp_lru_init_evp(ocf_cache_t cache, struct ocf_part *part) +void ocf_lru_init_evp(ocf_cache_t cache, struct ocf_part *part) { struct ocf_lru_list *clean_list; struct ocf_lru_list *dirty_list; uint32_t i; for (i = 0; i < OCF_NUM_EVICTION_LISTS; i++) { - clean_list = evp_lru_get_list(part, i, true); - dirty_list = evp_lru_get_list(part, i, false); + clean_list = ocf_lru_get_list(part, i, true); + dirty_list = ocf_lru_get_list(part, i, false); if (part->id == PARTITION_FREELIST) { _lru_init(clean_list, false); @@ -860,15 +860,15 @@ void evp_lru_init_evp(ocf_cache_t cache, struct ocf_part *part) env_atomic_set(&part->runtime->curr_size, 0); } -void evp_lru_clean_cline(ocf_cache_t cache, struct ocf_part *part, +void ocf_lru_clean_cline(ocf_cache_t cache, struct ocf_part *part, ocf_cache_line_t cline) { uint32_t ev_list = (cline % OCF_NUM_EVICTION_LISTS); struct ocf_lru_list *clean_list; struct ocf_lru_list *dirty_list; - clean_list = evp_lru_get_list(part, ev_list, true); - dirty_list = evp_lru_get_list(part, ev_list, false); + clean_list = ocf_lru_get_list(part, ev_list, true); + dirty_list = ocf_lru_get_list(part, ev_list, false); OCF_METADATA_EVICTION_WR_LOCK(cline); remove_lru_list(cache, dirty_list, cline); @@ -878,15 +878,15 @@ void evp_lru_clean_cline(ocf_cache_t cache, struct ocf_part *part, OCF_METADATA_EVICTION_WR_UNLOCK(cline); } -void evp_lru_dirty_cline(ocf_cache_t cache, struct ocf_part *part, +void ocf_lru_dirty_cline(ocf_cache_t cache, struct ocf_part *part, ocf_cache_line_t cline) { uint32_t ev_list = (cline % OCF_NUM_EVICTION_LISTS); struct ocf_lru_list *clean_list; struct ocf_lru_list *dirty_list; - clean_list = evp_lru_get_list(part, ev_list, true); - dirty_list = evp_lru_get_list(part, ev_list, false); + clean_list = ocf_lru_get_list(part, ev_list, true); + dirty_list = ocf_lru_get_list(part, ev_list, false); OCF_METADATA_EVICTION_WR_LOCK(cline); remove_lru_list(cache, clean_list, cline); @@ -941,7 +941,7 @@ void ocf_lru_populate(ocf_cache_t cache, ocf_cache_line_t num_free_clines) ocf_metadata_set_partition_id(cache, cline, PARTITION_FREELIST); ev_list = (cline % OCF_NUM_EVICTION_LISTS); - list = evp_lru_get_list(&cache->free, ev_list, true); + list = ocf_lru_get_list(&cache->free, ev_list, true); add_lru_head(cache, list, cline); balance_lru_list(cache, list); @@ -1026,7 +1026,7 @@ int ocf_metadata_actor(struct ocf_cache *cache, part = &cache->user_parts[part_id].part; for (i = 0; i < OCF_NUM_EVICTION_LISTS; i++) { for (clean = 0; clean <= 1; clean++) { - list = evp_lru_get_list(part, i, clean); + list = ocf_lru_get_list(part, i, clean); cline = list->tail; while (cline != end_marker) { diff --git a/src/ocf_lru.h b/src/ocf_lru.h index 73318ff..9c0589c 100644 --- a/src/ocf_lru.h +++ b/src/ocf_lru.h @@ -14,18 +14,18 @@ struct ocf_part_runtime; struct ocf_part_cleaning_ctx; struct ocf_request; -void evp_lru_init_cline(ocf_cache_t cache, ocf_cache_line_t cline); -void evp_lru_rm_cline(struct ocf_cache *cache, ocf_cache_line_t cline); -bool evp_lru_can_evict(struct ocf_cache *cache); -uint32_t evp_lru_req_clines(struct ocf_request *req, +void ocf_lru_init_cline(ocf_cache_t cache, ocf_cache_line_t cline); +void ocf_lru_rm_cline(struct ocf_cache *cache, ocf_cache_line_t cline); +bool ocf_lru_can_evict(struct ocf_cache *cache); +uint32_t ocf_lru_req_clines(struct ocf_request *req, struct ocf_part *src_part, uint32_t cline_no); -void evp_lru_hot_cline(struct ocf_cache *cache, ocf_cache_line_t cline); -void evp_lru_init_evp(struct ocf_cache *cache, struct ocf_part *part); -void evp_lru_dirty_cline(struct ocf_cache *cache, struct ocf_part *part, +void ocf_lru_hot_cline(struct ocf_cache *cache, ocf_cache_line_t cline); +void ocf_lru_init_evp(struct ocf_cache *cache, struct ocf_part *part); +void ocf_lru_dirty_cline(struct ocf_cache *cache, struct ocf_part *part, ocf_cache_line_t cline); -void evp_lru_clean_cline(struct ocf_cache *cache, struct ocf_part *part, +void ocf_lru_clean_cline(struct ocf_cache *cache, struct ocf_part *part, ocf_cache_line_t cline); -void evp_lru_clean(ocf_cache_t cache, struct ocf_user_part *user_part, +void ocf_lru_clean(ocf_cache_t cache, struct ocf_user_part *user_part, ocf_queue_t io_queue, uint32_t count); void ocf_lru_repart(ocf_cache_t cache, ocf_cache_line_t cline, struct ocf_part *src_upart, struct ocf_part *dst_upart); diff --git a/src/ocf_space.c b/src/ocf_space.c index 97f3ad8..878ed33 100644 --- a/src/ocf_space.c +++ b/src/ocf_space.c @@ -42,7 +42,7 @@ static inline uint32_t ocf_evict_part_do(struct ocf_request *req, return 0; } - return evp_lru_req_clines(req, &user_part->part, to_evict); + return ocf_lru_req_clines(req, &user_part->part, to_evict); } static inline uint32_t ocf_evict_user_partitions(ocf_cache_t cache, @@ -89,7 +89,7 @@ static inline uint32_t ocf_evict_user_partitions(ocf_cache_t cache, if (overflown_only) to_evict = OCF_MIN(to_evict, overflow_size); - evicted += evp_lru_req_clines(req, &user_part->part, to_evict); + evicted += ocf_lru_req_clines(req, &user_part->part, to_evict); if (evicted >= evict_cline_no) { /* Evicted requested number of cache line, stop @@ -113,7 +113,7 @@ static inline uint32_t ocf_remap_do(struct ocf_request *req) /* First attempt to map from freelist */ if (ocf_lru_num_free(cache) > 0) - remapped = evp_lru_req_clines(req, &cache->free, remap_cline_no); + remapped = ocf_lru_req_clines(req, &cache->free, remap_cline_no); if (remapped >= remap_cline_no) return remapped; diff --git a/src/utils/utils_cache_line.c b/src/utils/utils_cache_line.c index 96a2323..8be264e 100644 --- a/src/utils/utils_cache_line.c +++ b/src/utils/utils_cache_line.c @@ -132,7 +132,7 @@ void set_cache_line_clean(struct ocf_cache *cache, uint8_t start_bit, */ env_atomic_dec(&req->core->runtime_meta-> part_counters[part_id].dirty_clines); - evp_lru_clean_cline(cache, part, line); + ocf_lru_clean_cline(cache, part, line); ocf_purge_cleaning_policy(cache, line); } } @@ -174,7 +174,7 @@ void set_cache_line_dirty(struct ocf_cache *cache, uint8_t start_bit, */ env_atomic_inc(&req->core->runtime_meta-> part_counters[part_id].dirty_clines); - evp_lru_dirty_cline(cache, part, line); + ocf_lru_dirty_cline(cache, part, line); } } diff --git a/src/utils/utils_cache_line.h b/src/utils/utils_cache_line.h index 92f5d54..ec9510b 100644 --- a/src/utils/utils_cache_line.h +++ b/src/utils/utils_cache_line.h @@ -179,7 +179,7 @@ static inline void ocf_purge_cleaning_policy(struct ocf_cache *cache, static inline void ocf_purge_eviction_policy(struct ocf_cache *cache, ocf_cache_line_t line) { - evp_lru_rm_cline(cache, line); + ocf_lru_rm_cline(cache, line); } /** diff --git a/tests/unit/tests/ocf_lru.c/lru_iter.c b/tests/unit/tests/ocf_lru.c/lru_iter.c index 047bbb3..d2bc461 100644 --- a/tests/unit/tests/ocf_lru.c/lru_iter.c +++ b/tests/unit/tests/ocf_lru.c/lru_iter.c @@ -203,7 +203,7 @@ unsigned current_case; struct ocf_lru_list list; -struct ocf_lru_list *__wrap_evp_lru_get_list(struct ocf_user_part *user_part, +struct ocf_lru_list *__wrap_ocf_lru_get_list(struct ocf_user_part *user_part, uint32_t evp, bool clean) { unsigned i = 0; @@ -232,7 +232,7 @@ struct ocf_lru_list *__wrap_evp_lru_get_list(struct ocf_user_part *user_part, inline struct ocf_lru_list *__wrap_evp_get_cline_list(ocf_cache_t cache, ocf_cache_line_t cline) { - return __wrap_evp_lru_get_list(NULL, cline % OCF_NUM_EVICTION_LISTS, true); + return __wrap_ocf_lru_get_list(NULL, cline % OCF_NUM_EVICTION_LISTS, true); } diff --git a/tests/unit/tests/ocf_space.c/ocf_space.c b/tests/unit/tests/ocf_space.c/ocf_space.c index c7a4f47..b257be2 100644 --- a/tests/unit/tests/ocf_space.c/ocf_space.c +++ b/tests/unit/tests/ocf_space.c/ocf_space.c @@ -53,7 +53,7 @@ uint32_t __wrap_ocf_evict_calculate(ocf_cache_t cache, return min(tcache->evictable[user_part->part.id], to_evict); } -uint32_t __wrap_evp_lru_req_clines(struct ocf_request *req, +uint32_t __wrap_ocf_lru_req_clines(struct ocf_request *req, struct ocf_part *src_part, uint32_t cline_no) { struct test_cache *tcache = (struct test_cache *)req->cache; @@ -193,10 +193,10 @@ uint32_t __wrap_ocf_engine_unmapped_count(struct ocf_request *req) #define _expect_evict_call(tcache, part_id, req_count, ret_count) \ do { \ - expect_value(__wrap_evp_lru_req_clines, src_part, &tcache.cache.user_parts[part_id].part); \ - expect_value(__wrap_evp_lru_req_clines, cline_no, req_count); \ - expect_function_call(__wrap_evp_lru_req_clines); \ - will_return(__wrap_evp_lru_req_clines, ret_count); \ + expect_value(__wrap_ocf_lru_req_clines, src_part, &tcache.cache.user_parts[part_id].part); \ + expect_value(__wrap_ocf_lru_req_clines, cline_no, req_count); \ + expect_function_call(__wrap_ocf_lru_req_clines); \ + will_return(__wrap_ocf_lru_req_clines, ret_count); \ } while (false); static void ocf_remap_do_test01(void **state)