drivers/mempool/cnxk/cn10k_mempool_ops.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2021 Marvell.
   3  */
   4
   5 #include <rte_mempool.h>
   6
   7 #include "roc_api.h"
   8 #include "cnxk_mempool.h"
   9
  10 #define BATCH_ALLOC_SZ              ROC_CN10K_NPA_BATCH_ALLOC_MAX_PTRS
  11 #define BATCH_OP_DATA_TABLE_MZ_NAME "batch_op_data_table_mz"
  12
  13 enum batch_op_status {
  14         BATCH_ALLOC_OP_NOT_ISSUED = 0,
  15         BATCH_ALLOC_OP_ISSUED = 1,
  16         BATCH_ALLOC_OP_DONE
  17 };
  18
  19 struct batch_op_mem {
  20         unsigned int sz;
  21         enum batch_op_status status;
  22         uint64_t objs[BATCH_ALLOC_SZ] __rte_aligned(ROC_ALIGN);
  23 };
  24
  25 struct batch_op_data {
  26         uint64_t lmt_addr;
  27         struct batch_op_mem mem[RTE_MAX_LCORE] __rte_aligned(ROC_ALIGN);
  28 };
  29
  30 static struct batch_op_data **batch_op_data_tbl;
  31
  32 static int
  33 batch_op_data_table_create(void)
  34 {
  35         const struct rte_memzone *mz;
  36
  37         /* If table is already set, nothing to do */
  38         if (batch_op_data_tbl)
  39                 return 0;
  40
  41         mz = rte_memzone_lookup(BATCH_OP_DATA_TABLE_MZ_NAME);
  42         if (mz == NULL) {
  43                 if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
  44                         unsigned int maxpools, sz;
  45
  46                         maxpools = roc_idev_npa_maxpools_get();
  47                         sz = maxpools * sizeof(struct batch_op_data *);
  48
  49                         mz = rte_memzone_reserve_aligned(
  50                                 BATCH_OP_DATA_TABLE_MZ_NAME, sz, SOCKET_ID_ANY,
  51                                 0, ROC_ALIGN);
  52                 }
  53                 if (mz == NULL) {
  54                         plt_err("Failed to reserve batch op data table");
  55                         return -ENOMEM;
  56                 }
  57         }
  58         batch_op_data_tbl = mz->addr;
  59         rte_wmb();
  60         return 0;
  61 }
  62
  63 static inline struct batch_op_data *
  64 batch_op_data_get(uint64_t pool_id)
  65 {
  66         uint64_t aura = roc_npa_aura_handle_to_aura(pool_id);
  67
  68         return batch_op_data_tbl[aura];
  69 }
  70
  71 static inline void
  72 batch_op_data_set(uint64_t pool_id, struct batch_op_data *op_data)
  73 {
  74         uint64_t aura = roc_npa_aura_handle_to_aura(pool_id);
  75
  76         batch_op_data_tbl[aura] = op_data;
  77 }
  78
  79 static int
  80 batch_op_init(struct rte_mempool *mp)
  81 {
  82         struct batch_op_data *op_data;
  83         int i;
  84
  85         op_data = batch_op_data_get(mp->pool_id);
  86         /* The data should not have been allocated previously */
  87         RTE_ASSERT(op_data == NULL);
  88
  89         op_data = rte_zmalloc(NULL, sizeof(struct batch_op_data), ROC_ALIGN);
  90         if (op_data == NULL)
  91                 return -ENOMEM;
  92
  93         for (i = 0; i < RTE_MAX_LCORE; i++) {
  94                 op_data->mem[i].sz = 0;
  95                 op_data->mem[i].status = BATCH_ALLOC_OP_NOT_ISSUED;
  96         }
  97
  98         op_data->lmt_addr = roc_idev_lmt_base_addr_get();
  99         batch_op_data_set(mp->pool_id, op_data);
 100         rte_wmb();
 101
 102         return 0;
 103 }
 104
 105 static void
 106 batch_op_fini(struct rte_mempool *mp)
 107 {
 108         struct batch_op_data *op_data;
 109         int i;
 110
 111         op_data = batch_op_data_get(mp->pool_id);
 112         if (!op_data) {
 113                 /* Batch op data can be uninitialized in case of empty
 114                  * mempools.
 115                  */
 116                 return;
 117         }
 118
 119         rte_wmb();
 120         for (i = 0; i < RTE_MAX_LCORE; i++) {
 121                 struct batch_op_mem *mem = &op_data->mem[i];
 122
 123                 if (mem->status == BATCH_ALLOC_OP_ISSUED) {
 124                         mem->sz = roc_npa_aura_batch_alloc_extract(
 125                                 mem->objs, mem->objs, BATCH_ALLOC_SZ);
 126                         mem->status = BATCH_ALLOC_OP_DONE;
 127                 }
 128                 if (mem->status == BATCH_ALLOC_OP_DONE) {
 129                         roc_npa_aura_op_bulk_free(mp->pool_id, mem->objs,
 130                                                   mem->sz, 1);
 131                         mem->status = BATCH_ALLOC_OP_NOT_ISSUED;
 132                 }
 133         }
 134
 135         rte_free(op_data);
 136         batch_op_data_set(mp->pool_id, NULL);
 137         rte_wmb();
 138 }
 139
 140 static int __rte_hot
 141 cn10k_mempool_enq(struct rte_mempool *mp, void *const *obj_table,
 142                   unsigned int n)
 143 {
 144         const uint64_t *ptr = (const uint64_t *)obj_table;
 145         uint64_t lmt_addr = 0, lmt_id = 0;
 146         struct batch_op_data *op_data;
 147
 148         /* Ensure mbuf init changes are written before the free pointers are
 149          * enqueued to the stack.
 150          */
 151         rte_io_wmb();
 152
 153         if (n == 1) {
 154                 roc_npa_aura_op_free(mp->pool_id, 1, ptr[0]);
 155                 return 0;
 156         }
 157
 158         op_data = batch_op_data_get(mp->pool_id);
 159         lmt_addr = op_data->lmt_addr;
 160         ROC_LMT_BASE_ID_GET(lmt_addr, lmt_id);
 161         roc_npa_aura_op_batch_free(mp->pool_id, ptr, n, 1, lmt_addr, lmt_id);
 162
 163         return 0;
 164 }
 165
 166 static unsigned int
 167 cn10k_mempool_get_count(const struct rte_mempool *mp)
 168 {
 169         struct batch_op_data *op_data;
 170         unsigned int count = 0;
 171         int i;
 172
 173         op_data = batch_op_data_get(mp->pool_id);
 174
 175         rte_wmb();
 176         for (i = 0; i < RTE_MAX_LCORE; i++) {
 177                 struct batch_op_mem *mem = &op_data->mem[i];
 178
 179                 if (mem->status == BATCH_ALLOC_OP_ISSUED)
 180                         count += roc_npa_aura_batch_alloc_count(mem->objs,
 181                                                                 BATCH_ALLOC_SZ);
 182
 183                 if (mem->status == BATCH_ALLOC_OP_DONE)
 184                         count += mem->sz;
 185         }
 186
 187         count += cnxk_mempool_get_count(mp);
 188
 189         return count;
 190 }
 191
 192 static int __rte_hot
 193 cn10k_mempool_deq(struct rte_mempool *mp, void **obj_table, unsigned int n)
 194 {
 195         struct batch_op_data *op_data;
 196         struct batch_op_mem *mem;
 197         unsigned int count = 0;
 198         int tid, rc, retry;
 199         bool loop = true;
 200
 201         op_data = batch_op_data_get(mp->pool_id);
 202         tid = rte_lcore_id();
 203         mem = &op_data->mem[tid];
 204
 205         /* Issue batch alloc */
 206         if (mem->status == BATCH_ALLOC_OP_NOT_ISSUED) {
 207                 rc = roc_npa_aura_batch_alloc_issue(mp->pool_id, mem->objs,
 208                                                     BATCH_ALLOC_SZ, 0, 1);
 209                 /* If issue fails, try falling back to default alloc */
 210                 if (unlikely(rc))
 211                         return cnxk_mempool_deq(mp, obj_table, n);
 212                 mem->status = BATCH_ALLOC_OP_ISSUED;
 213         }
 214
 215         retry = 4;
 216         while (loop) {
 217                 unsigned int cur_sz;
 218
 219                 if (mem->status == BATCH_ALLOC_OP_ISSUED) {
 220                         mem->sz = roc_npa_aura_batch_alloc_extract(
 221                                 mem->objs, mem->objs, BATCH_ALLOC_SZ);
 222
 223                         /* If partial alloc reduce the retry count */
 224                         retry -= (mem->sz != BATCH_ALLOC_SZ);
 225                         /* Break the loop if retry count exhausted */
 226                         loop = !!retry;
 227                         mem->status = BATCH_ALLOC_OP_DONE;
 228                 }
 229
 230                 cur_sz = n - count;
 231                 if (cur_sz > mem->sz)
 232                         cur_sz = mem->sz;
 233
 234                 /* Dequeue the pointers */
 235                 memcpy(&obj_table[count], &mem->objs[mem->sz - cur_sz],
 236                        cur_sz * sizeof(uintptr_t));
 237                 mem->sz -= cur_sz;
 238                 count += cur_sz;
 239
 240                 /* Break loop if the required pointers has been dequeued */
 241                 loop &= (count != n);
 242
 243                 /* Issue next batch alloc if pointers are exhausted */
 244                 if (mem->sz == 0) {
 245                         rc = roc_npa_aura_batch_alloc_issue(
 246                                 mp->pool_id, mem->objs, BATCH_ALLOC_SZ, 0, 1);
 247                         /* Break loop if issue failed and set status */
 248                         loop &= !rc;
 249                         mem->status = !rc;
 250                 }
 251         }
 252
 253         if (unlikely(count != n)) {
 254                 /* No partial alloc allowed. Free up allocated pointers */
 255                 cn10k_mempool_enq(mp, obj_table, count);
 256                 return -ENOENT;
 257         }
 258
 259         return 0;
 260 }
 261
 262 static int
 263 cn10k_mempool_alloc(struct rte_mempool *mp)
 264 {
 265         uint32_t block_size;
 266         size_t padding;
 267         int rc;
 268
 269         block_size = mp->elt_size + mp->header_size + mp->trailer_size;
 270         /* Align header size to ROC_ALIGN */
 271         if (mp->header_size % ROC_ALIGN != 0) {
 272                 padding = RTE_ALIGN_CEIL(mp->header_size, ROC_ALIGN) -
 273                           mp->header_size;
 274                 mp->header_size += padding;
 275                 block_size += padding;
 276         }
 277
 278         /* Align block size to ROC_ALIGN */
 279         if (block_size % ROC_ALIGN != 0) {
 280                 padding = RTE_ALIGN_CEIL(block_size, ROC_ALIGN) - block_size;
 281                 mp->trailer_size += padding;
 282                 block_size += padding;
 283         }
 284
 285         rc = cnxk_mempool_alloc(mp);
 286         if (rc)
 287                 return rc;
 288
 289         rc = batch_op_init(mp);
 290         if (rc) {
 291                 plt_err("Failed to init batch alloc mem rc=%d", rc);
 292                 goto error;
 293         }
 294
 295         return 0;
 296 error:
 297         cnxk_mempool_free(mp);
 298         return rc;
 299 }
 300
 301 static void
 302 cn10k_mempool_free(struct rte_mempool *mp)
 303 {
 304         batch_op_fini(mp);
 305         cnxk_mempool_free(mp);
 306 }
 307
 308 int
 309 cn10k_mempool_plt_init(void)
 310 {
 311         return batch_op_data_table_create();
 312 }
 313
 314 static struct rte_mempool_ops cn10k_mempool_ops = {
 315         .name = "cn10k_mempool_ops",
 316         .alloc = cn10k_mempool_alloc,
 317         .free = cn10k_mempool_free,
 318         .enqueue = cn10k_mempool_enq,
 319         .dequeue = cn10k_mempool_deq,
 320         .get_count = cn10k_mempool_get_count,
 321         .calc_mem_size = cnxk_mempool_calc_mem_size,
 322         .populate = cnxk_mempool_populate,
 323 };
 324
 325 RTE_MEMPOOL_REGISTER_OPS(cn10k_mempool_ops);