From 8b93b699c3433f2a8f0fd774da857e7e3361ed22 Mon Sep 17 00:00:00 2001 From: Robert Baldyga Date: Mon, 19 Feb 2024 22:25:57 +0100 Subject: [PATCH] Eliminate queue -> cache mapping Eliminate need to resolve cache based on the queue. This allows to share the queue between cache instances. The queue still holds pointer to a cache that owns the queue, but no management or io path relies on the queue -> cache mapping. Signed-off-by: Robert Baldyga Signed-off-by: Michal Mielewczyk --- inc/ocf_queue.h | 8 ++-- src/metadata/metadata_io.c | 2 +- src/metadata/metadata_raw_dynamic.c | 2 +- src/mngt/ocf_mngt_flush.c | 2 +- src/ocf_core.c | 3 +- src/ocf_queue.c | 13 +++-- src/ocf_request.c | 74 ++++++++++++++++++++++++----- src/ocf_request.h | 19 +++++++- src/utils/utils_cleaner.c | 3 +- src/utils/utils_parallelize.c | 2 +- src/utils/utils_pipeline.c | 2 +- 11 files changed, 98 insertions(+), 32 deletions(-) diff --git a/inc/ocf_queue.h b/inc/ocf_queue.h index 2a59103..47d9d4c 100644 --- a/inc/ocf_queue.h +++ b/inc/ocf_queue.h @@ -153,12 +153,12 @@ void *ocf_queue_get_priv(ocf_queue_t q); uint32_t ocf_queue_pending_io(ocf_queue_t q); /** - * @brief Get cache instance to which I/O queue belongs + * @brief Return if queue is management queue * - * @param[in] q I/O queue + * @param[in] queue - queue object * - * @retval Cache instance + * @retval true - if management queue, otherwise false */ -ocf_cache_t ocf_queue_get_cache(ocf_queue_t q); +bool ocf_queue_is_mngt(ocf_queue_t queue); #endif diff --git a/src/metadata/metadata_io.c b/src/metadata/metadata_io.c index 9be1d2f..b4521a9 100644 --- a/src/metadata/metadata_io.c +++ b/src/metadata/metadata_io.c @@ -156,7 +156,7 @@ int metadata_io_read_i_atomic(ocf_cache_t cache, ocf_queue_t queue, void *priv, if (!context) return -OCF_ERR_NO_MEM; - context->req = ocf_req_new(queue, NULL, 0, 0, 0); + context->req = ocf_req_new_mngt(cache, queue); if (!context->req) { env_vfree(context); return -OCF_ERR_NO_MEM; diff --git a/src/metadata/metadata_raw_dynamic.c b/src/metadata/metadata_raw_dynamic.c index bde407b..9e394c8 100644 --- a/src/metadata/metadata_raw_dynamic.c +++ b/src/metadata/metadata_raw_dynamic.c @@ -493,7 +493,7 @@ void raw_dynamic_load_all(ocf_cache_t cache, struct ocf_metadata_raw *raw, goto err_zpage; } - context->req = ocf_req_new_mngt(cache->mngt_queue); + context->req = ocf_req_new_mngt(cache, cache->mngt_queue); if (!context->req) { result = -OCF_ERR_NO_MEM; goto err_req; diff --git a/src/mngt/ocf_mngt_flush.c b/src/mngt/ocf_mngt_flush.c index d4dcda3..a0ca152 100644 --- a/src/mngt/ocf_mngt_flush.c +++ b/src/mngt/ocf_mngt_flush.c @@ -432,7 +432,7 @@ static void _ocf_mngt_flush_container( fc->end = end; fc->context = context; - req = ocf_req_new_mngt(cache->mngt_queue); + req = ocf_req_new_mngt(cache, cache->mngt_queue); if (!req) { error = OCF_ERR_NO_MEM; goto finish; diff --git a/src/ocf_core.c b/src/ocf_core.c index 38f324a..4088260 100644 --- a/src/ocf_core.c +++ b/src/ocf_core.c @@ -489,9 +489,10 @@ static void *ocf_core_io_allocator_new(ocf_io_allocator_t allocator, ocf_volume_t volume, ocf_queue_t queue, uint64_t addr, uint32_t bytes, uint32_t dir) { + ocf_core_t core = ocf_volume_to_core(volume); struct ocf_request *req; - req = ocf_req_new(queue, NULL, addr, bytes, dir); + req = ocf_req_new(queue, core, addr, bytes, dir); if (!req) return NULL; diff --git a/src/ocf_queue.c b/src/ocf_queue.c index cb985aa..c77524a 100644 --- a/src/ocf_queue.c +++ b/src/ocf_queue.c @@ -126,6 +126,11 @@ int ocf_queue_create_mngt(ocf_cache_t cache, ocf_queue_t *queue, return 0; } +bool ocf_queue_is_mngt(ocf_queue_t queue) +{ + return queue == queue->cache->mngt_queue; +} + void ocf_queue_get(ocf_queue_t queue) { OCF_CHECK_NULL(queue); @@ -144,7 +149,7 @@ void ocf_queue_put(ocf_queue_t queue) return; queue->ops->stop(queue); - if (queue != queue->cache->mngt_queue) { + if (!ocf_queue_is_mngt(queue)) { env_spinlock_lock_irqsave(&cache->io_queues_lock, flags); list_del(&queue->list); env_spinlock_unlock_irqrestore(&cache->io_queues_lock, flags); @@ -247,12 +252,6 @@ uint32_t ocf_queue_pending_io(ocf_queue_t q) return env_atomic_read(&q->io_no); } -ocf_cache_t ocf_queue_get_cache(ocf_queue_t q) -{ - OCF_CHECK_NULL(q); - return q->cache; -} - void ocf_queue_push_req(struct ocf_request *req, uint flags) { ocf_cache_t cache = req->cache; diff --git a/src/ocf_request.c b/src/ocf_request.c index 682a351..a0bd245 100644 --- a/src/ocf_request.c +++ b/src/ocf_request.c @@ -81,13 +81,14 @@ void ocf_req_allocator_deinit(struct ocf_ctx *ocf_ctx) ocf_ctx->resources.req = NULL; } -static inline void ocf_req_init(struct ocf_request *req, ocf_queue_t queue, - ocf_core_t core, uint64_t addr, uint32_t bytes, int rw) +static inline void ocf_req_init(struct ocf_request *req, ocf_cache_t cache, + ocf_queue_t queue, ocf_core_t core, + uint64_t addr, uint32_t bytes, int rw) { req->io_queue = queue; req->core = core; - req->cache = queue->cache; + req->cache = cache; env_atomic_set(&req->ref_count, 1); @@ -96,7 +97,7 @@ static inline void ocf_req_init(struct ocf_request *req, ocf_queue_t queue, req->rw = rw; } -struct ocf_request *ocf_req_new_mngt(ocf_queue_t queue) +struct ocf_request *ocf_req_new_mngt(ocf_cache_t cache, ocf_queue_t queue) { struct ocf_request *req; @@ -106,23 +107,23 @@ struct ocf_request *ocf_req_new_mngt(ocf_queue_t queue) ocf_queue_get(queue); - ocf_req_init(req, queue, NULL, 0, 0, 0); + ocf_req_init(req, cache, queue, NULL, 0, 0, 0); req->is_mngt = true; return req; } -struct ocf_request *ocf_req_new_cleaner(ocf_queue_t queue, uint32_t count) +struct ocf_request *ocf_req_new_cleaner(ocf_cache_t cache, ocf_queue_t queue, + uint32_t count) { - ocf_cache_t cache = queue->cache; struct ocf_request *req; bool map_allocated = true, is_mngt = false; if (!ocf_refcnt_inc(&cache->refcnt.metadata)) return NULL; - if (unlikely(queue == cache->mngt_queue)) { + if (unlikely(ocf_queue_is_mngt(queue))) { req = env_zalloc(sizeof(*req) + ocf_req_sizeof_map(count) + ocf_req_sizeof_alock_status(count), ENV_MEM_NORMAL); @@ -143,7 +144,7 @@ struct ocf_request *ocf_req_new_cleaner(ocf_queue_t queue, uint32_t count) ocf_queue_get(queue); - ocf_req_init(req, queue, NULL, 0, 0, OCF_READ); + ocf_req_init(req, cache, queue, NULL, 0, 0, OCF_READ); if (map_allocated) { req->map = req->__map; @@ -167,11 +168,11 @@ struct ocf_request *ocf_req_new(ocf_queue_t queue, ocf_core_t core, uint64_t addr, uint32_t bytes, int rw) { uint64_t core_line_first, core_line_last, core_line_count; - ocf_cache_t cache = queue->cache; + ocf_cache_t cache = ocf_core_get_cache(core); struct ocf_request *req; bool map_allocated = true; - ENV_BUG_ON(queue == cache->mngt_queue); + ENV_BUG_ON(ocf_queue_is_mngt(queue)); if (likely(bytes)) { core_line_first = ocf_bytes_2_lines(cache, addr); @@ -204,7 +205,7 @@ struct ocf_request *ocf_req_new(ocf_queue_t queue, ocf_core_t core, ocf_queue_get(queue); - ocf_req_init(req, queue, core, addr, bytes, rw); + ocf_req_init(req, cache, queue, core, addr, bytes, rw); req->d2c = !ocf_refcnt_inc(&cache->refcnt.metadata); @@ -223,6 +224,55 @@ struct ocf_request *ocf_req_new(ocf_queue_t queue, ocf_core_t core, return req; } +struct ocf_request *ocf_req_new_cache(ocf_cache_t cache, ocf_queue_t queue, + uint64_t addr, uint32_t bytes, int rw) +{ + uint64_t core_line_first, core_line_last, core_line_count; + struct ocf_request *req; + bool map_allocated = true; + + ENV_BUG_ON(ocf_queue_is_mngt(queue)); + + if (!ocf_refcnt_inc(&cache->refcnt.metadata)) + return NULL; + + ocf_queue_get(queue); + + if (likely(bytes)) { + core_line_first = ocf_bytes_2_lines(cache, addr); + core_line_last = ocf_bytes_2_lines(cache, addr + bytes - 1); + core_line_count = core_line_last - core_line_first + 1; + } else { + core_line_count = 1; + } + + req = env_mpool_new(cache->owner->resources.req, core_line_count); + if (!req) { + map_allocated = false; + req = env_mpool_new(cache->owner->resources.req, 1); + } + + if (unlikely(!req)) { + ocf_refcnt_dec(&cache->refcnt.metadata); + ocf_queue_put(queue); + return NULL; + } + + if (map_allocated) { + req->map = req->__map; + req->alock_status = (uint8_t *)&req->__map[core_line_count]; + req->alloc_core_line_count = core_line_count; + } else { + req->alloc_core_line_count = 1; + } + + ocf_req_init(req, cache, queue, NULL, addr, bytes, rw); + + req->lock_idx = ocf_metadata_concurrency_next_idx(queue); + + return req; +} + int ocf_req_alloc_map(struct ocf_request *req) { uint32_t lines = req->core_line_count; diff --git a/src/ocf_request.h b/src/ocf_request.h index ae3d87d..2872a8b 100644 --- a/src/ocf_request.h +++ b/src/ocf_request.h @@ -288,7 +288,7 @@ void ocf_req_allocator_deinit(struct ocf_ctx *ocf_ctx); * * @return new OCF request */ -struct ocf_request *ocf_req_new_mngt(ocf_queue_t queue); +struct ocf_request *ocf_req_new_mngt(ocf_cache_t cache, ocf_queue_t queue); /** * @brief Allocate new OCF request for cleaner @@ -298,7 +298,8 @@ struct ocf_request *ocf_req_new_mngt(ocf_queue_t queue); * * @return new OCF request */ -struct ocf_request *ocf_req_new_cleaner(ocf_queue_t queue, uint32_t count); +struct ocf_request *ocf_req_new_cleaner(ocf_cache_t cache, ocf_queue_t queue, + uint32_t count); /** * @brief Allocate new OCF request @@ -314,6 +315,20 @@ struct ocf_request *ocf_req_new_cleaner(ocf_queue_t queue, uint32_t count); struct ocf_request *ocf_req_new(ocf_queue_t queue, ocf_core_t core, uint64_t addr, uint32_t bytes, int rw); +/** + * @brief Allocate new OCF request for cache IO + * + * @param cache - OCF cache instance + * @param queue - I/O queue handle + * @param addr - LBA of request + * @param bytes - number of bytes of request + * @param rw - Read or Write + * + * @return new OCF request + */ +struct ocf_request *ocf_req_new_cache(ocf_cache_t cache, ocf_queue_t queue, + uint64_t addr, uint32_t bytes, int rw); + /** * @brief Allocate OCF request map * diff --git a/src/utils/utils_cleaner.c b/src/utils/utils_cleaner.c index 2d3240d..fc34def 100644 --- a/src/utils/utils_cleaner.c +++ b/src/utils/utils_cleaner.c @@ -40,9 +40,10 @@ static struct ocf_request *_ocf_cleaner_alloc_req(struct ocf_cache *cache, uint32_t count, const struct ocf_cleaner_attribs *attribs) { - struct ocf_request *req = ocf_req_new_cleaner(attribs->io_queue, count); + struct ocf_request *req; int ret; + req = ocf_req_new_cleaner(cache, attribs->io_queue, count); if (!req) return NULL; diff --git a/src/utils/utils_parallelize.c b/src/utils/utils_parallelize.c index 53db392..85eba9e 100644 --- a/src/utils/utils_parallelize.c +++ b/src/utils/utils_parallelize.c @@ -105,7 +105,7 @@ int ocf_parallelize_create(ocf_parallelize_t *parallelize, } else { queue = cache->mngt_queue; } - tmp_parallelize->reqs[i] = ocf_req_new_mngt(queue); + tmp_parallelize->reqs[i] = ocf_req_new_mngt(cache, queue); if (!tmp_parallelize->reqs[i]) { result = -OCF_ERR_NO_MEM; goto err_reqs; diff --git a/src/utils/utils_pipeline.c b/src/utils/utils_pipeline.c index ee0698e..8744af7 100644 --- a/src/utils/utils_pipeline.c +++ b/src/utils/utils_pipeline.c @@ -87,7 +87,7 @@ int ocf_pipeline_create(ocf_pipeline_t *pipeline, ocf_cache_t cache, tmp_pipeline->priv = (void *)priv; } - req = ocf_req_new_mngt(cache->mngt_queue); + req = ocf_req_new_mngt(cache, cache->mngt_queue); if (!req) { env_vfree(tmp_pipeline); return -OCF_ERR_NO_MEM;