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