177 lines
5.3 KiB
Diff
177 lines
5.3 KiB
Diff
From 0290582355c4c7f1a30c80b206f62d7ddaa2de05 Mon Sep 17 00:00:00 2001
|
|
From: Erez Shitrit <erezsh@mellanox.com>
|
|
Date: Thu, 20 Feb 2020 15:27:30 +0200
|
|
Subject: [PATCH 2/8] mlx5: Allocate accurate aligned DM memory size
|
|
|
|
[ Upstream commit 96bd5476194106deb4c9edaf405e92646623465a ]
|
|
|
|
Allocate the exact memory size and only when failed to allocate an aligned
|
|
memory size fallback to allocate double size of DM memory.
|
|
|
|
Fixes: 6235899cdf7a ("mlx5: ICM pool memory allocator")
|
|
Signed-off-by: Erez Shitrit <erezsh@mellanox.com>
|
|
Reviewed-by: Alex Vesker <valex@mellanox.com>
|
|
Signed-off-by: Yishai Hadas <yishaih@mellanox.com>
|
|
Signed-off-by: Nicolas Morey-Chaisemartin <nmoreychaisemartin@suse.com>
|
|
---
|
|
providers/mlx5/dr_icm_pool.c | 103 ++++++++++++++++++++++-------------
|
|
1 file changed, 64 insertions(+), 39 deletions(-)
|
|
|
|
diff --git a/providers/mlx5/dr_icm_pool.c b/providers/mlx5/dr_icm_pool.c
|
|
index 1e2853959b37..469e52552ccd 100644
|
|
--- a/providers/mlx5/dr_icm_pool.c
|
|
+++ b/providers/mlx5/dr_icm_pool.c
|
|
@@ -89,16 +89,72 @@ struct dr_icm_mr {
|
|
struct list_node mr_list;
|
|
};
|
|
|
|
-static struct dr_icm_mr *
|
|
-dr_icm_pool_mr_create(struct dr_icm_pool *pool,
|
|
- enum mlx5_ib_uapi_dm_type dm_type,
|
|
- size_t align_base)
|
|
+static int
|
|
+dr_icm_allocate_aligned_dm(struct dr_icm_pool *pool,
|
|
+ struct dr_icm_mr *icm_mr,
|
|
+ struct ibv_alloc_dm_attr *dm_attr)
|
|
{
|
|
struct mlx5dv_alloc_dm_attr mlx5_dm_attr = {};
|
|
+ size_t log_align_base = 0;
|
|
+ bool fallback = false;
|
|
+ struct mlx5_dm *dm;
|
|
+ size_t size;
|
|
+
|
|
+ /* create dm/mr for this pool */
|
|
+ size = dr_icm_pool_chunk_size_to_byte(pool->max_log_chunk_sz,
|
|
+ pool->icm_type);
|
|
+
|
|
+ if (pool->icm_type == DR_ICM_TYPE_STE) {
|
|
+ mlx5_dm_attr.type = MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM;
|
|
+ /* Align base is the biggest chunk size */
|
|
+ log_align_base = ilog32(size - 1);
|
|
+ } else if (pool->icm_type == DR_ICM_TYPE_MODIFY_ACTION) {
|
|
+ mlx5_dm_attr.type = MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM;
|
|
+ /* Align base is 64B */
|
|
+ log_align_base = ilog32(DR_ICM_MODIFY_HDR_ALIGN_BASE - 1);
|
|
+ }
|
|
+
|
|
+ dm_attr->length = size;
|
|
+
|
|
+alloc_dm:
|
|
+ icm_mr->dm = mlx5dv_alloc_dm(pool->dmn->ctx, dm_attr, &mlx5_dm_attr);
|
|
+ if (!icm_mr->dm) {
|
|
+ dr_dbg(pool->dmn, "Failed allocating DM\n");
|
|
+ return errno;
|
|
+ }
|
|
+
|
|
+ dm = to_mdm(icm_mr->dm);
|
|
+ icm_mr->icm_start_addr = dm->remote_va;
|
|
+
|
|
+ if (icm_mr->icm_start_addr & ((1UL << log_align_base) - 1)) {
|
|
+ uint64_t align_base;
|
|
+ uint64_t align_diff;
|
|
+
|
|
+ /* Fallback to previous implementation, ask for double size */
|
|
+ dr_dbg(pool->dmn, "Got not aligned memory: %zu last_try: %d\n",
|
|
+ log_align_base, fallback);
|
|
+ if (fallback) {
|
|
+ align_base = 1UL << log_align_base;
|
|
+ align_diff = icm_mr->icm_start_addr % align_base;
|
|
+ icm_mr->used_length = align_base - align_diff;
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ mlx5_free_dm(icm_mr->dm);
|
|
+ /* retry to allocate, now double the size */
|
|
+ dm_attr->length = size * 2;
|
|
+ fallback = true;
|
|
+ goto alloc_dm;
|
|
+ }
|
|
+
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+static struct dr_icm_mr *
|
|
+dr_icm_pool_mr_create(struct dr_icm_pool *pool)
|
|
+{
|
|
struct ibv_alloc_dm_attr dm_attr = {};
|
|
struct dr_icm_mr *icm_mr;
|
|
- struct mlx5_dm *dm;
|
|
- size_t align_diff;
|
|
|
|
icm_mr = calloc(1, sizeof(struct dr_icm_mr));
|
|
if (!icm_mr) {
|
|
@@ -106,20 +162,8 @@ dr_icm_pool_mr_create(struct dr_icm_pool *pool,
|
|
return NULL;
|
|
}
|
|
|
|
- icm_mr->pool = pool;
|
|
- list_node_init(&icm_mr->mr_list);
|
|
-
|
|
- mlx5_dm_attr.type = dm_type;
|
|
-
|
|
- /* 2^log_biggest_table * entry-size * double-for-alignment */
|
|
- dm_attr.length = dr_icm_pool_chunk_size_to_byte(pool->max_log_chunk_sz,
|
|
- pool->icm_type) * 2;
|
|
-
|
|
- icm_mr->dm = mlx5dv_alloc_dm(pool->dmn->ctx, &dm_attr, &mlx5_dm_attr);
|
|
- if (!icm_mr->dm) {
|
|
- dr_dbg(pool->dmn, "Failed allocating DM\n");
|
|
+ if (dr_icm_allocate_aligned_dm(pool, icm_mr, &dm_attr))
|
|
goto free_icm_mr;
|
|
- }
|
|
|
|
/* Register device memory */
|
|
icm_mr->mr = ibv_reg_dm_mr(pool->dmn->pd, icm_mr->dm, 0,
|
|
@@ -133,13 +177,6 @@ dr_icm_pool_mr_create(struct dr_icm_pool *pool,
|
|
goto free_dm;
|
|
}
|
|
|
|
- dm = to_mdm(icm_mr->dm);
|
|
- icm_mr->icm_start_addr = dm->remote_va;
|
|
-
|
|
- align_diff = icm_mr->icm_start_addr % align_base;
|
|
- if (align_diff)
|
|
- icm_mr->used_length = align_base - align_diff;
|
|
-
|
|
list_add_tail(&pool->icm_mr_list, &icm_mr->mr_list);
|
|
|
|
return icm_mr;
|
|
@@ -199,33 +236,21 @@ static int dr_icm_chunks_create(struct dr_icm_bucket *bucket)
|
|
{
|
|
size_t mr_free_size, mr_req_size, mr_row_size;
|
|
struct dr_icm_pool *pool = bucket->pool;
|
|
- enum mlx5_ib_uapi_dm_type dm_type;
|
|
struct dr_icm_chunk *chunk;
|
|
struct dr_icm_mr *icm_mr;
|
|
- size_t align_base;
|
|
int i;
|
|
|
|
mr_req_size = bucket->num_of_entries * bucket->entry_size;
|
|
mr_row_size = dr_icm_pool_chunk_size_to_byte(pool->max_log_chunk_sz,
|
|
pool->icm_type);
|
|
|
|
- if (pool->icm_type == DR_ICM_TYPE_STE) {
|
|
- dm_type = MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM;
|
|
- /* Align base is the biggest chunk size / row size */
|
|
- align_base = mr_row_size;
|
|
- } else {
|
|
- dm_type = MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM;
|
|
- /* Align base is 64B */
|
|
- align_base = DR_ICM_MODIFY_HDR_ALIGN_BASE;
|
|
- }
|
|
-
|
|
pthread_mutex_lock(&pool->mr_mutex);
|
|
icm_mr = list_tail(&pool->icm_mr_list, struct dr_icm_mr, mr_list);
|
|
if (icm_mr)
|
|
mr_free_size = icm_mr->mr->length - icm_mr->used_length;
|
|
|
|
if (!icm_mr || mr_free_size < mr_row_size) {
|
|
- icm_mr = dr_icm_pool_mr_create(pool, dm_type, align_base);
|
|
+ icm_mr = dr_icm_pool_mr_create(pool);
|
|
if (!icm_mr)
|
|
goto out_err;
|
|
}
|
|
--
|
|
2.25.4
|
|
|