Backfill optimization

src/cleaning/acp.c

@@ -549,7 +549,7 @@ static ocf_cache_line_t _acp_trylock_dirty(struct ocf_cache *cache,
 	ocf_engine_lookup_map_entry(cache, &info, core_id,
 			core_line);
 
-	if (info.status == LOOKUP_HIT &&
+	if ((info.status == LOOKUP_HIT || info.status == LOOKUP_HIT_INVALID) &&
 			metadata_test_dirty(cache, info.coll_idx)) {
 		locked = ocf_cache_line_try_lock_rd(
 				ocf_cache_line_concurrency(cache),

src/engine/cache_engine.h

@@ -14,6 +14,7 @@ struct ocf_thread_priv;
 #define LOOKUP_HIT 5
 #define LOOKUP_MISS 6
 #define LOOKUP_REMAPPED 8
+#define LOOKUP_HIT_INVALID 9
 
 static inline ocf_req_cache_mode_t ocf_cache_mode_to_req_cache_mode(
 		ocf_cache_mode_t mode)

src/engine/engine_bf.c

@@ -68,15 +68,91 @@ static void _ocf_backfill_complete(struct ocf_request *req, int error)
 	}
 }
 
+#define __entries_not_adjacent(__req, __i, __j) \
+	__req->map[__i].coll_idx + 1 != __req->map[__j].coll_idx
+
+#define __is_the_last_chunk(__req, __i) (__i == (__req->core_line_count - 1))
+
+#define __skip_on_the_last_entry(__skip, __req, __i) \
+	__skip * (int)__is_the_last_chunk(__req, __i)
+
 static int _ocf_backfill_do(struct ocf_request *req)
 {
+	ocf_cache_t cache = req->cache;
+	uint64_t metadata_offset = cache->device->metadata_offset;
+	ocf_cache_line_size_t cache_line_size = ocf_line_size(cache);
+	uint64_t addr, bytes, total_bytes = 0;
+	uint64_t seek, skip, last_chunk_size;
+	uint32_t i;
+
 	req->data = req->cp_data;
 	if (unlikely(req->data == NULL)) {
 		_ocf_backfill_complete(req, -OCF_ERR_NO_MEM);
 		return 0;
 	}
 
-	ocf_engine_forward_cache_io_req(req, OCF_WRITE, _ocf_backfill_complete);
+	req->cache_forward_end = _ocf_backfill_complete;
+
+	if (ocf_engine_is_sequential(req)) {
+		addr = metadata_offset;
+		addr += req->map[0].coll_idx * cache_line_size;
+		addr += req->addr % cache_line_size;
+
+		ocf_core_stats_cache_block_update(req->core, req->part_id,
+				OCF_WRITE, req->bytes);
+
+		ocf_req_forward_cache_io(req, OCF_WRITE, addr, req->bytes,
+				req->offset);
+		return 0;
+	}
+
+	seek = req->addr % cache_line_size;
+	last_chunk_size = (req->addr + req->bytes) % cache_line_size;
+	skip = (cache_line_size - last_chunk_size) % cache_line_size;
+
+	ocf_req_forward_cache_get(req);
+	for (i = 0; i < req->core_line_count; i++) {
+		if (req->map[i].status == LOOKUP_HIT) {
+			/* This is the 1st cache line in the interval, and it's
+			   a hit. Don't write it to the cache */
+			total_bytes += cache_line_size;
+			total_bytes -= seek;
+			/* Seek should be taken into account for the first chunk
+			   only */
+			seek = 0;
+			continue;
+		}
+
+		addr = metadata_offset;
+		addr += req->map[i].coll_idx * cache_line_size;
+
+		bytes = cache_line_size;
+		for (; i < (req->core_line_count - 1); i++) {
+			if (__entries_not_adjacent(req, i, i + 1))
+				break;
+
+			bytes += cache_line_size;
+		}
+
+		/* Seek should be taken into account for the first chunk only */
+		addr += seek;
+		bytes -= seek;
+		seek = 0;
+
+		bytes -= __skip_on_the_last_entry(skip, req, i);
+
+		bytes = OCF_MIN(bytes, req->bytes - total_bytes);
+
+		ocf_core_stats_cache_block_update(req->core, req->part_id,
+				OCF_WRITE, bytes);
+
+		ocf_req_forward_cache_io(req, OCF_WRITE, addr, bytes,
+				req->offset + total_bytes);
+
+		total_bytes += bytes;
+	}
+
+	ocf_req_forward_cache_put(req);
 
 	return 0;
 }

src/engine/engine_common.c

@@ -143,7 +143,8 @@ static void ocf_engine_update_req_info(struct ocf_cache *cache,
 
 	ENV_BUG_ON(entry->status != LOOKUP_HIT &&
 			entry->status != LOOKUP_MISS &&
-			entry->status != LOOKUP_REMAPPED);
+			entry->status != LOOKUP_REMAPPED &&
+			entry->status != LOOKUP_HIT_INVALID);
 
 	/* Handle return value */
 	if (entry->status == LOOKUP_HIT) {
@@ -152,6 +153,7 @@ static void ocf_engine_update_req_info(struct ocf_cache *cache,
 			req->info.hit_no++;
 		} else {
 			req->info.invalid_no++;
+			entry->status = LOOKUP_HIT_INVALID;
 		}
 
 		/* Check request is dirty */
@@ -165,7 +167,7 @@ static void ocf_engine_update_req_info(struct ocf_cache *cache,
 		}
 	}
 
-	if (entry->status == LOOKUP_HIT || entry->status == LOOKUP_REMAPPED) {
+	if (entry->status == LOOKUP_HIT || entry->status == LOOKUP_HIT_INVALID || entry->status == LOOKUP_REMAPPED) {
 		if (req->part_id != ocf_metadata_get_partition_id(cache,
 				entry->coll_idx)) {
 			/*
@@ -201,7 +203,7 @@ void ocf_engine_set_hot(struct ocf_request *req)
 		entry = &(req->map[i]);
 		status = entry->status;
 
-		if (status == LOOKUP_HIT) {
+		if (status == LOOKUP_HIT || status == LOOKUP_HIT_INVALID) {
 			/* Update eviction (LRU) */
 			ocf_lru_hot_cline(cache, entry->coll_idx);
 		}
@@ -330,6 +332,7 @@ static void ocf_engine_map_hndl_error(struct ocf_cache *cache,
 
 		switch (entry->status) {
 		case LOOKUP_HIT:
+		case LOOKUP_HIT_INVALID:
 		case LOOKUP_MISS:
 			break;
 
@@ -537,7 +540,7 @@ static int _ocf_engine_clean_getter(struct ocf_cache *cache,
 
 	entry = &req->map[item];
 
-	if (entry->status != LOOKUP_HIT)
+	if (entry->status != LOOKUP_HIT && entry->status != LOOKUP_HIT_INVALID)
 		return -1;
 
 	if (!metadata_test_dirty(cache, entry->coll_idx))

src/utils/utils_user_part.c

@@ -1,5 +1,6 @@
 /*
  * Copyright(c) 2012-2021 Intel Corporation
+ * Copyright(c) 2024 Huawei Technologies
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
@@ -112,7 +113,7 @@ void ocf_user_part_move(struct ocf_request *req)
 		 * cachelines are assigned to target partition during eviction.
 		 * So only hit cachelines are interesting.
 		 */
-		if (entry->status != LOOKUP_HIT) {
+		if (entry->status != LOOKUP_HIT && entry->status != LOOKUP_HIT_INVALID) {
 			/* No HIT */
 			continue;
 		}