Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (c) 2023 Marvell.
3 : : */
4 : :
5 : : #include <rte_mldev.h>
6 : : #include <rte_mldev_pmd.h>
7 : :
8 : : #include <mldev_utils.h>
9 : :
10 : : #include "cnxk_ml_dev.h"
11 : : #include "cnxk_ml_io.h"
12 : : #include "cnxk_ml_model.h"
13 : : #include "cnxk_ml_ops.h"
14 : :
15 : : /* ML model macros */
16 : : #define CNXK_ML_MODEL_MEMZONE_NAME "ml_cnxk_model_mz"
17 : :
18 : : __rte_hot void
19 : 0 : cnxk_ml_set_poll_ptr(struct cnxk_ml_req *req)
20 : : {
21 : 0 : plt_write64(ML_CNXK_POLL_JOB_START, req->status);
22 : 0 : }
23 : :
24 : : __rte_hot uint64_t
25 : 0 : cnxk_ml_get_poll_ptr(struct cnxk_ml_req *req)
26 : : {
27 : 0 : return plt_read64(req->status);
28 : : }
29 : :
30 : : static void
31 : : qp_memzone_name_get(char *name, int size, int dev_id, int qp_id)
32 : : {
33 : : snprintf(name, size, "cnxk_ml_qp_mem_%u:%u", dev_id, qp_id);
34 : : }
35 : :
36 : : static int
37 : 0 : cnxk_ml_qp_destroy(const struct rte_ml_dev *dev, struct cnxk_ml_qp *qp)
38 : : {
39 : : const struct rte_memzone *qp_mem;
40 : : char name[RTE_MEMZONE_NAMESIZE];
41 : : int ret;
42 : :
43 : 0 : qp_memzone_name_get(name, RTE_MEMZONE_NAMESIZE, dev->data->dev_id, qp->id);
44 : 0 : qp_mem = rte_memzone_lookup(name);
45 : 0 : ret = rte_memzone_free(qp_mem);
46 [ # # ]: 0 : if (ret)
47 : : return ret;
48 : :
49 : 0 : rte_free(qp);
50 : :
51 : 0 : return 0;
52 : : }
53 : :
54 : : static int
55 : 0 : cnxk_ml_dev_queue_pair_release(struct rte_ml_dev *dev, uint16_t queue_pair_id)
56 : : {
57 : : struct cnxk_ml_qp *qp;
58 : : int ret;
59 : :
60 : 0 : qp = dev->data->queue_pairs[queue_pair_id];
61 [ # # ]: 0 : if (qp == NULL)
62 : : return -EINVAL;
63 : :
64 : 0 : ret = cnxk_ml_qp_destroy(dev, qp);
65 [ # # ]: 0 : if (ret) {
66 : 0 : plt_err("Could not destroy queue pair %u", queue_pair_id);
67 : 0 : return ret;
68 : : }
69 : :
70 : 0 : dev->data->queue_pairs[queue_pair_id] = NULL;
71 : :
72 : 0 : return 0;
73 : : }
74 : :
75 : : static struct cnxk_ml_qp *
76 : 0 : cnxk_ml_qp_create(const struct rte_ml_dev *dev, uint16_t qp_id, uint32_t nb_desc, int socket_id)
77 : : {
78 : : const struct rte_memzone *qp_mem;
79 : : char name[RTE_MEMZONE_NAMESIZE];
80 : : struct cnxk_ml_dev *cnxk_mldev;
81 : : struct cnxk_ml_qp *qp;
82 : : uint32_t len;
83 : : uint8_t *va;
84 : :
85 : 0 : cnxk_mldev = dev->data->dev_private;
86 : :
87 : : /* Allocate queue pair */
88 : 0 : qp = rte_zmalloc_socket("cnxk_ml_pmd_queue_pair", sizeof(struct cnxk_ml_qp), ROC_ALIGN,
89 : : socket_id);
90 [ # # ]: 0 : if (qp == NULL) {
91 : 0 : plt_err("Could not allocate queue pair");
92 : 0 : return NULL;
93 : : }
94 : :
95 : : /* For request queue */
96 : 0 : len = nb_desc * sizeof(struct cnxk_ml_req);
97 : 0 : qp_memzone_name_get(name, RTE_MEMZONE_NAMESIZE, dev->data->dev_id, qp_id);
98 : 0 : qp_mem = rte_memzone_reserve_aligned(
99 : : name, len, socket_id, RTE_MEMZONE_SIZE_HINT_ONLY | RTE_MEMZONE_256MB, ROC_ALIGN);
100 [ # # ]: 0 : if (qp_mem == NULL) {
101 : 0 : plt_err("Could not reserve memzone: %s", name);
102 : 0 : goto qp_free;
103 : : }
104 : :
105 : 0 : va = qp_mem->addr;
106 : : memset(va, 0, len);
107 : :
108 : : /* Initialize Request queue */
109 : 0 : qp->id = qp_id;
110 : 0 : qp->queue.reqs = (struct cnxk_ml_req *)va;
111 : 0 : qp->queue.head = 0;
112 : 0 : qp->queue.tail = 0;
113 : 0 : qp->queue.wait_cycles = ML_CNXK_CMD_TIMEOUT * plt_tsc_hz();
114 : 0 : qp->nb_desc = nb_desc;
115 : 0 : qp->stats.enqueued_count = 0;
116 : 0 : qp->stats.dequeued_count = 0;
117 : 0 : qp->stats.enqueue_err_count = 0;
118 : 0 : qp->stats.dequeue_err_count = 0;
119 : :
120 [ # # ]: 0 : if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_PCI)
121 : 0 : cn10k_ml_qp_initialize(cnxk_mldev, qp);
122 : :
123 : : return qp;
124 : :
125 : : qp_free:
126 : 0 : rte_free(qp);
127 : :
128 : 0 : return NULL;
129 : : }
130 : :
131 : : static int
132 : 0 : cnxk_ml_xstats_init(struct cnxk_ml_dev *cnxk_mldev)
133 : : {
134 : : uint16_t nb_stats;
135 : : uint16_t stat_id;
136 : : uint16_t model;
137 : : uint16_t layer;
138 : : uint16_t i;
139 : :
140 : : /* Allocate memory for xstats entries. Don't allocate during reconfigure */
141 : : nb_stats = RTE_DIM(device_xstats) +
142 : : RTE_DIM(layer_xstats) * ML_CNXK_MAX_MODELS * ML_CNXK_MODEL_MAX_LAYERS +
143 : : RTE_DIM(model_xstats) * ML_CNXK_MAX_MODELS;
144 [ # # ]: 0 : if (cnxk_mldev->xstats.entries == NULL)
145 : 0 : cnxk_mldev->xstats.entries = rte_zmalloc(
146 : : "cnxk_ml_xstats", sizeof(struct cnxk_ml_xstats_entry) * nb_stats,
147 : : PLT_CACHE_LINE_SIZE);
148 : :
149 [ # # ]: 0 : if (cnxk_mldev->xstats.entries == NULL)
150 : : return -ENOMEM;
151 : :
152 : : /* Initialize device xstats */
153 : : stat_id = 0;
154 [ # # ]: 0 : for (i = 0; i < RTE_DIM(device_xstats); i++) {
155 : 0 : cnxk_mldev->xstats.entries[stat_id].map.id = stat_id;
156 : 0 : snprintf(cnxk_mldev->xstats.entries[stat_id].map.name,
157 : : sizeof(cnxk_mldev->xstats.entries[stat_id].map.name), "%s",
158 : 0 : device_xstats[i].name);
159 : :
160 : 0 : cnxk_mldev->xstats.entries[stat_id].mode = RTE_ML_DEV_XSTATS_DEVICE;
161 : 0 : cnxk_mldev->xstats.entries[stat_id].group = CNXK_ML_XSTATS_GROUP_DEVICE;
162 : 0 : cnxk_mldev->xstats.entries[stat_id].type = device_xstats[i].type;
163 : 0 : cnxk_mldev->xstats.entries[stat_id].fn_id = CNXK_ML_XSTATS_FN_DEVICE;
164 : 0 : cnxk_mldev->xstats.entries[stat_id].obj_idx = 0;
165 : 0 : cnxk_mldev->xstats.entries[stat_id].reset_allowed = device_xstats[i].reset_allowed;
166 : 0 : stat_id++;
167 : : }
168 : 0 : cnxk_mldev->xstats.count_mode_device = stat_id;
169 : :
170 : : /* Initialize model xstats */
171 [ # # ]: 0 : for (model = 0; model < ML_CNXK_MAX_MODELS; model++) {
172 : 0 : cnxk_mldev->xstats.offset_for_model[model] = stat_id;
173 : :
174 [ # # ]: 0 : for (i = 0; i < RTE_DIM(model_xstats); i++) {
175 : 0 : cnxk_mldev->xstats.entries[stat_id].map.id = stat_id;
176 : 0 : cnxk_mldev->xstats.entries[stat_id].mode = RTE_ML_DEV_XSTATS_MODEL;
177 : 0 : cnxk_mldev->xstats.entries[stat_id].group = CNXK_ML_XSTATS_GROUP_MODEL;
178 : 0 : cnxk_mldev->xstats.entries[stat_id].type = model_xstats[i].type;
179 : 0 : cnxk_mldev->xstats.entries[stat_id].fn_id = CNXK_ML_XSTATS_FN_MODEL;
180 : 0 : cnxk_mldev->xstats.entries[stat_id].obj_idx = model;
181 : 0 : cnxk_mldev->xstats.entries[stat_id].layer_id = -1;
182 : 0 : cnxk_mldev->xstats.entries[stat_id].reset_allowed =
183 : 0 : model_xstats[i].reset_allowed;
184 : :
185 : : /* Name of xstat is updated during model load */
186 : 0 : snprintf(cnxk_mldev->xstats.entries[stat_id].map.name,
187 : : sizeof(cnxk_mldev->xstats.entries[stat_id].map.name),
188 : 0 : "Model-%u-%s", model, model_xstats[i].name);
189 : :
190 : 0 : stat_id++;
191 : : }
192 : :
193 [ # # ]: 0 : for (layer = 0; layer < ML_CNXK_MODEL_MAX_LAYERS; layer++) {
194 : 0 : cnxk_mldev->xstats.offset_for_layer[model][layer] = stat_id;
195 : :
196 [ # # ]: 0 : for (i = 0; i < RTE_DIM(layer_xstats); i++) {
197 : 0 : cnxk_mldev->xstats.entries[stat_id].map.id = stat_id;
198 : 0 : cnxk_mldev->xstats.entries[stat_id].mode = RTE_ML_DEV_XSTATS_MODEL;
199 : 0 : cnxk_mldev->xstats.entries[stat_id].group =
200 : : CNXK_ML_XSTATS_GROUP_LAYER;
201 : 0 : cnxk_mldev->xstats.entries[stat_id].type = layer_xstats[i].type;
202 : 0 : cnxk_mldev->xstats.entries[stat_id].fn_id = CNXK_ML_XSTATS_FN_MODEL;
203 : 0 : cnxk_mldev->xstats.entries[stat_id].obj_idx = model;
204 : 0 : cnxk_mldev->xstats.entries[stat_id].layer_id = layer;
205 : 0 : cnxk_mldev->xstats.entries[stat_id].reset_allowed =
206 : 0 : layer_xstats[i].reset_allowed;
207 : :
208 : : /* Name of xstat is updated during model load */
209 : 0 : snprintf(cnxk_mldev->xstats.entries[stat_id].map.name,
210 : : sizeof(cnxk_mldev->xstats.entries[stat_id].map.name),
211 : 0 : "Layer-%u-%u-%s", model, layer, layer_xstats[i].name);
212 : :
213 : 0 : stat_id++;
214 : : }
215 : :
216 : 0 : cnxk_mldev->xstats.count_per_layer[model][layer] = RTE_DIM(layer_xstats);
217 : : }
218 : :
219 : 0 : cnxk_mldev->xstats.count_per_model[model] =
220 : : RTE_DIM(layer_xstats) + ML_CNXK_MODEL_MAX_LAYERS * RTE_DIM(model_xstats);
221 : : }
222 : :
223 : 0 : cnxk_mldev->xstats.count_mode_model = stat_id - cnxk_mldev->xstats.count_mode_device;
224 : 0 : cnxk_mldev->xstats.count = stat_id;
225 : :
226 : 0 : return 0;
227 : : }
228 : :
229 : : void
230 : 0 : cnxk_ml_xstats_model_name_update(struct cnxk_ml_dev *cnxk_mldev, uint16_t model_id)
231 : : {
232 : : struct cnxk_ml_model *model;
233 : : uint16_t rclk_freq;
234 : : uint16_t sclk_freq;
235 : : uint16_t stat_id;
236 : : char suffix[8];
237 : : uint16_t i;
238 : :
239 : 0 : model = cnxk_mldev->mldev->data->models[model_id];
240 : 0 : stat_id = cnxk_mldev->xstats.offset_for_model[model_id];
241 : :
242 : 0 : roc_clk_freq_get(&rclk_freq, &sclk_freq);
243 [ # # ]: 0 : if (sclk_freq == 0)
244 : 0 : rte_strscpy(suffix, "cycles", 7);
245 : : else
246 : 0 : rte_strscpy(suffix, "ns", 3);
247 : :
248 : : /* Update xstat name based on layer name and sclk availability */
249 [ # # ]: 0 : for (i = 0; i < RTE_DIM(model_xstats); i++) {
250 [ # # ]: 0 : if (model->type == ML_CNXK_MODEL_TYPE_GLOW)
251 : 0 : cn10k_ml_xstat_model_name_set(cnxk_mldev, model, stat_id, i, suffix);
252 : : else
253 : 0 : tvmrt_ml_model_xstat_name_set(cnxk_mldev, model, stat_id, i, suffix);
254 : :
255 : 0 : stat_id++;
256 : : }
257 : 0 : }
258 : :
259 : : static void
260 : : cnxk_ml_xstats_uninit(struct cnxk_ml_dev *cnxk_mldev)
261 : : {
262 : 0 : rte_free(cnxk_mldev->xstats.entries);
263 : 0 : cnxk_mldev->xstats.entries = NULL;
264 : :
265 : 0 : cnxk_mldev->xstats.count = 0;
266 : : }
267 : :
268 : : static uint64_t
269 : 0 : cnxk_ml_dev_xstat_get(struct cnxk_ml_dev *cnxk_mldev, uint16_t obj_idx __rte_unused,
270 : : int32_t layer_id __rte_unused, enum cnxk_ml_xstats_type type)
271 : : {
272 [ # # # # : 0 : switch (type) {
# ]
273 : 0 : case nb_models_loaded:
274 : 0 : return cnxk_mldev->nb_models_loaded;
275 : 0 : case nb_models_unloaded:
276 : 0 : return cnxk_mldev->nb_models_unloaded;
277 : 0 : case nb_models_started:
278 : 0 : return cnxk_mldev->nb_models_started;
279 : 0 : case nb_models_stopped:
280 : 0 : return cnxk_mldev->nb_models_stopped;
281 : : default:
282 : : return -1;
283 : : }
284 : :
285 : : return 0;
286 : : }
287 : :
288 : : static uint64_t
289 : 0 : cnxk_ml_model_xstat_get(struct cnxk_ml_dev *cnxk_mldev, uint16_t obj_idx, int32_t layer_id,
290 : : enum cnxk_ml_xstats_type type)
291 : : {
292 : : struct cnxk_ml_model *model;
293 : : struct cnxk_ml_layer *layer;
294 : : uint16_t rclk_freq; /* MHz */
295 : : uint16_t sclk_freq; /* MHz */
296 : : uint64_t value = 0;
297 : :
298 : 0 : model = cnxk_mldev->mldev->data->models[obj_idx];
299 [ # # ]: 0 : if (model == NULL)
300 : : return 0;
301 : :
302 [ # # ]: 0 : if (layer_id >= 0) {
303 : 0 : layer = &model->layer[layer_id];
304 : 0 : goto layer_xstats;
305 : : } else {
306 : : layer = NULL;
307 : 0 : goto model_xstats;
308 : : }
309 : :
310 : : layer_xstats:
311 : 0 : value = cn10k_ml_model_xstat_get(cnxk_mldev, layer, type);
312 : 0 : goto exit_xstats;
313 : :
314 : : model_xstats:
315 : 0 : value = tvmrt_ml_model_xstat_get(cnxk_mldev, model, type);
316 : :
317 : 0 : exit_xstats:
318 : 0 : roc_clk_freq_get(&rclk_freq, &sclk_freq);
319 [ # # ]: 0 : if (sclk_freq != 0) /* return in ns */
320 : 0 : value = (value * 1000ULL) / sclk_freq;
321 : :
322 : : return value;
323 : : }
324 : :
325 : : static int
326 : 0 : cnxk_ml_device_xstats_reset(struct cnxk_ml_dev *cnxk_mldev, const uint16_t stat_ids[],
327 : : uint16_t nb_ids)
328 : : {
329 : : struct cnxk_ml_xstats_entry *xs;
330 : : uint16_t nb_stats;
331 : : uint16_t stat_id;
332 : : uint32_t i;
333 : :
334 [ # # ]: 0 : if (stat_ids == NULL)
335 : 0 : nb_stats = cnxk_mldev->xstats.count_mode_device;
336 : : else
337 : : nb_stats = nb_ids;
338 : :
339 [ # # ]: 0 : for (i = 0; i < nb_stats; i++) {
340 [ # # ]: 0 : if (stat_ids == NULL)
341 : 0 : stat_id = i;
342 : : else
343 : 0 : stat_id = stat_ids[i];
344 : :
345 [ # # ]: 0 : if (stat_id >= cnxk_mldev->xstats.count_mode_device)
346 : : return -EINVAL;
347 : :
348 : 0 : xs = &cnxk_mldev->xstats.entries[stat_id];
349 [ # # ]: 0 : if (!xs->reset_allowed)
350 : 0 : continue;
351 : :
352 : 0 : xs->reset_value =
353 [ # # # # : 0 : cnxk_ml_dev_xstat_get(cnxk_mldev, xs->obj_idx, xs->layer_id, xs->type);
# ]
354 : : }
355 : :
356 : : return 0;
357 : : }
358 : :
359 : : #define ML_AVG_RESET_FOREACH_QP(cnxk_mldev, layer, qp_id, str) \
360 : : do { \
361 : : for (qp_id = 0; qp_id < cnxk_mldev->mldev->data->nb_queue_pairs; qp_id++) { \
362 : : layer->glow.burst_xstats[qp_id].str##_latency_tot = 0; \
363 : : layer->glow.burst_xstats[qp_id].str##_reset_count = \
364 : : layer->glow.burst_xstats[qp_id].dequeued_count; \
365 : : } \
366 : : } while (0)
367 : :
368 : : #define ML_MIN_RESET_FOREACH_QP(cnxk_mldev, layer, qp_id, str) \
369 : : do { \
370 : : for (qp_id = 0; qp_id < cnxk_mldev->mldev->data->nb_queue_pairs; qp_id++) \
371 : : layer->glow.burst_xstats[qp_id].str##_latency_min = UINT64_MAX; \
372 : : } while (0)
373 : :
374 : : #define ML_MAX_RESET_FOREACH_QP(cnxk_mldev, layer, qp_id, str) \
375 : : do { \
376 : : for (qp_id = 0; qp_id < cnxk_mldev->mldev->data->nb_queue_pairs; qp_id++) \
377 : : layer->glow.burst_xstats[qp_id].str##_latency_max = 0; \
378 : : } while (0)
379 : :
380 : : static void
381 : 0 : cnxk_ml_reset_model_stat(struct cnxk_ml_dev *cnxk_mldev, uint16_t model_id,
382 : : enum cnxk_ml_xstats_type type)
383 : : {
384 : : struct cnxk_ml_model *model;
385 : : struct cnxk_ml_layer *layer;
386 : : uint16_t layer_id = 0;
387 : : uint32_t qp_id;
388 : :
389 : 0 : model = cnxk_mldev->mldev->data->models[model_id];
390 : : layer = &model->layer[layer_id];
391 : :
392 [ # # # # : 0 : switch (type) {
# # # ]
393 : : case avg_hw_latency:
394 [ # # ]: 0 : ML_AVG_RESET_FOREACH_QP(cnxk_mldev, layer, qp_id, hw);
395 : : break;
396 : : case min_hw_latency:
397 [ # # ]: 0 : ML_MIN_RESET_FOREACH_QP(cnxk_mldev, layer, qp_id, hw);
398 : : break;
399 : : case max_hw_latency:
400 [ # # ]: 0 : ML_MAX_RESET_FOREACH_QP(cnxk_mldev, layer, qp_id, hw);
401 : : break;
402 : : case avg_fw_latency:
403 [ # # ]: 0 : ML_AVG_RESET_FOREACH_QP(cnxk_mldev, layer, qp_id, fw);
404 : : break;
405 : : case min_fw_latency:
406 [ # # ]: 0 : ML_MIN_RESET_FOREACH_QP(cnxk_mldev, layer, qp_id, fw);
407 : : break;
408 : : case max_fw_latency:
409 [ # # ]: 0 : ML_MAX_RESET_FOREACH_QP(cnxk_mldev, layer, qp_id, fw);
410 : : break;
411 : : default:
412 : : return;
413 : : }
414 : : }
415 : :
416 : : static int
417 : 0 : cnxk_ml_model_xstats_reset(struct cnxk_ml_dev *cnxk_mldev, int32_t model_id,
418 : : const uint16_t stat_ids[], uint16_t nb_ids)
419 : : {
420 : : struct cnxk_ml_xstats_entry *xs;
421 : : struct cnxk_ml_model *model;
422 : : int32_t lcl_model_id = 0;
423 : : uint16_t layer_id = 0;
424 : : uint16_t start_id;
425 : : uint16_t end_id;
426 : : int32_t i;
427 : : int32_t j;
428 : :
429 [ # # ]: 0 : for (i = 0; i < ML_CNXK_MAX_MODELS; i++) {
430 [ # # ]: 0 : if (model_id == -1) {
431 : 0 : model = cnxk_mldev->mldev->data->models[i];
432 [ # # ]: 0 : if (model == NULL) /* skip inactive models */
433 : 0 : continue;
434 : : } else {
435 [ # # ]: 0 : if (model_id != i)
436 : 0 : continue;
437 : :
438 : 0 : model = cnxk_mldev->mldev->data->models[model_id];
439 [ # # ]: 0 : if (model == NULL) {
440 : 0 : plt_err("Invalid model_id = %d", model_id);
441 : 0 : return -EINVAL;
442 : : }
443 : : }
444 : :
445 : 0 : start_id = cnxk_mldev->xstats.offset_for_layer[i][layer_id];
446 : 0 : end_id = cnxk_mldev->xstats.offset_for_layer[i][layer_id] +
447 : 0 : cnxk_mldev->xstats.count_per_layer[i][layer_id] - 1;
448 : :
449 [ # # ]: 0 : if (stat_ids == NULL) {
450 [ # # ]: 0 : for (j = start_id; j <= end_id; j++) {
451 : 0 : xs = &cnxk_mldev->xstats.entries[j];
452 : 0 : cnxk_ml_reset_model_stat(cnxk_mldev, i, xs->type);
453 : : }
454 : : } else {
455 [ # # ]: 0 : for (j = 0; j < nb_ids; j++) {
456 [ # # # # ]: 0 : if (stat_ids[j] < start_id || stat_ids[j] > end_id) {
457 : 0 : plt_err("Invalid stat_ids[%d] = %d for model_id = %d", j,
458 : : stat_ids[j], lcl_model_id);
459 : 0 : return -EINVAL;
460 : : }
461 : 0 : xs = &cnxk_mldev->xstats.entries[stat_ids[j]];
462 : 0 : cnxk_ml_reset_model_stat(cnxk_mldev, i, xs->type);
463 : : }
464 : : }
465 : : }
466 : :
467 : : return 0;
468 : : }
469 : :
470 : : static int
471 : 0 : cnxk_ml_dev_info_get(struct rte_ml_dev *dev, struct rte_ml_dev_info *dev_info)
472 : : {
473 : : struct cnxk_ml_dev *cnxk_mldev;
474 : :
475 [ # # ]: 0 : if (dev == NULL || dev_info == NULL)
476 : : return -EINVAL;
477 : :
478 [ # # ]: 0 : cnxk_mldev = dev->data->dev_private;
479 : :
480 : : memset(dev_info, 0, sizeof(struct rte_ml_dev_info));
481 : 0 : dev_info->driver_name = dev->device->driver->name;
482 : 0 : dev_info->max_models = ML_CNXK_MAX_MODELS;
483 : :
484 [ # # ]: 0 : if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_PCI)
485 : 0 : return cn10k_ml_dev_info_get(cnxk_mldev, dev_info);
486 : : else
487 : 0 : return mvtvm_ml_dev_info_get(cnxk_mldev, dev_info);
488 : :
489 : : return 0;
490 : : }
491 : :
492 : : static int
493 : 0 : cnxk_ml_dev_configure(struct rte_ml_dev *dev, const struct rte_ml_dev_config *conf)
494 : : {
495 : : struct rte_ml_dev_info dev_info;
496 : : struct cnxk_ml_dev *cnxk_mldev;
497 : : struct cnxk_ml_model *model;
498 : : struct cnxk_ml_qp *qp;
499 : : uint16_t model_id;
500 : : uint32_t mz_size;
501 : : uint16_t qp_id;
502 : : uint64_t i;
503 : : int ret;
504 : :
505 [ # # ]: 0 : if (dev == NULL)
506 : : return -EINVAL;
507 : :
508 : : /* Get CNXK device handle */
509 : 0 : cnxk_mldev = dev->data->dev_private;
510 : :
511 : 0 : cnxk_ml_dev_info_get(dev, &dev_info);
512 [ # # ]: 0 : if (conf->nb_models > dev_info.max_models) {
513 : 0 : plt_err("Invalid device config, nb_models > %u", dev_info.max_models);
514 : 0 : return -EINVAL;
515 : : }
516 : :
517 [ # # ]: 0 : if (conf->nb_queue_pairs > dev_info.max_queue_pairs) {
518 : 0 : plt_err("Invalid device config, nb_queue_pairs > %u", dev_info.max_queue_pairs);
519 : 0 : return -EINVAL;
520 : : }
521 : :
522 [ # # ]: 0 : if (cnxk_mldev->state == ML_CNXK_DEV_STATE_PROBED) {
523 : 0 : plt_ml_dbg("Configuring ML device, nb_queue_pairs = %u, nb_models = %u",
524 : : conf->nb_queue_pairs, conf->nb_models);
525 : :
526 : : /* Load firmware */
527 [ # # ]: 0 : if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_PCI) {
528 : 0 : ret = cn10k_ml_fw_load(cnxk_mldev);
529 [ # # ]: 0 : if (ret != 0)
530 : : return ret;
531 : : }
532 [ # # ]: 0 : } else if (cnxk_mldev->state == ML_CNXK_DEV_STATE_CONFIGURED) {
533 : 0 : plt_ml_dbg("Re-configuring ML device, nb_queue_pairs = %u, nb_models = %u",
534 : : conf->nb_queue_pairs, conf->nb_models);
535 [ # # ]: 0 : } else if (cnxk_mldev->state == ML_CNXK_DEV_STATE_STARTED) {
536 : 0 : plt_err("Device can't be reconfigured in started state");
537 : 0 : return -ENOTSUP;
538 [ # # ]: 0 : } else if (cnxk_mldev->state == ML_CNXK_DEV_STATE_CLOSED) {
539 : 0 : plt_err("Device can't be reconfigured after close");
540 : 0 : return -ENOTSUP;
541 : : }
542 : :
543 : : /* Configure queue-pairs */
544 [ # # ]: 0 : if (dev->data->queue_pairs == NULL) {
545 : 0 : mz_size = sizeof(dev->data->queue_pairs[0]) * conf->nb_queue_pairs;
546 : 0 : dev->data->queue_pairs =
547 : 0 : rte_zmalloc("cnxk_mldev_queue_pairs", mz_size, RTE_CACHE_LINE_SIZE);
548 [ # # ]: 0 : if (dev->data->queue_pairs == NULL) {
549 : 0 : dev->data->nb_queue_pairs = 0;
550 : 0 : plt_err("Failed to get memory for queue_pairs, nb_queue_pairs %u",
551 : : conf->nb_queue_pairs);
552 : 0 : return -ENOMEM;
553 : : }
554 : : } else { /* Re-configure */
555 : : void **queue_pairs;
556 : :
557 : : /* Release all queue pairs as ML spec doesn't support queue_pair_destroy. */
558 [ # # ]: 0 : for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
559 : 0 : qp = dev->data->queue_pairs[qp_id];
560 [ # # ]: 0 : if (qp != NULL) {
561 : 0 : ret = cnxk_ml_dev_queue_pair_release(dev, qp_id);
562 [ # # ]: 0 : if (ret < 0)
563 : 0 : return ret;
564 : : }
565 : : }
566 : :
567 : 0 : queue_pairs = dev->data->queue_pairs;
568 : : queue_pairs =
569 : 0 : rte_realloc(queue_pairs, sizeof(queue_pairs[0]) * conf->nb_queue_pairs,
570 : : RTE_CACHE_LINE_SIZE);
571 [ # # ]: 0 : if (queue_pairs == NULL) {
572 : 0 : dev->data->nb_queue_pairs = 0;
573 : 0 : plt_err("Failed to realloc queue_pairs, nb_queue_pairs = %u",
574 : : conf->nb_queue_pairs);
575 : : ret = -ENOMEM;
576 : 0 : goto error;
577 : : }
578 : :
579 : 0 : memset(queue_pairs, 0, sizeof(queue_pairs[0]) * conf->nb_queue_pairs);
580 : 0 : dev->data->queue_pairs = queue_pairs;
581 : : }
582 : 0 : dev->data->nb_queue_pairs = conf->nb_queue_pairs;
583 : :
584 : : /* Allocate ML models */
585 [ # # ]: 0 : if (dev->data->models == NULL) {
586 : 0 : mz_size = sizeof(dev->data->models[0]) * conf->nb_models;
587 : 0 : dev->data->models = rte_zmalloc("cnxk_mldev_models", mz_size, RTE_CACHE_LINE_SIZE);
588 [ # # ]: 0 : if (dev->data->models == NULL) {
589 : 0 : dev->data->nb_models = 0;
590 : 0 : plt_err("Failed to get memory for ml_models, nb_models %u",
591 : : conf->nb_models);
592 : : ret = -ENOMEM;
593 : 0 : goto error;
594 : : }
595 : : } else {
596 : : /* Re-configure */
597 : : void **models;
598 : :
599 : : /* Stop and unload all models */
600 [ # # ]: 0 : for (model_id = 0; model_id < dev->data->nb_models; model_id++) {
601 : 0 : model = dev->data->models[model_id];
602 [ # # ]: 0 : if (model != NULL) {
603 [ # # ]: 0 : if (model->state == ML_CNXK_MODEL_STATE_STARTED) {
604 [ # # ]: 0 : if (cnxk_ml_model_stop(dev, model_id) != 0)
605 : 0 : plt_err("Could not stop model %u", model_id);
606 : : }
607 [ # # ]: 0 : if (model->state == ML_CNXK_MODEL_STATE_LOADED) {
608 [ # # ]: 0 : if (cnxk_ml_model_unload(dev, model_id) != 0)
609 : 0 : plt_err("Could not unload model %u", model_id);
610 : : }
611 : 0 : dev->data->models[model_id] = NULL;
612 : : }
613 : : }
614 : :
615 : 0 : models = dev->data->models;
616 : 0 : models = rte_realloc(models, sizeof(models[0]) * conf->nb_models,
617 : : RTE_CACHE_LINE_SIZE);
618 [ # # ]: 0 : if (models == NULL) {
619 : 0 : dev->data->nb_models = 0;
620 : 0 : plt_err("Failed to realloc ml_models, nb_models = %u", conf->nb_models);
621 : : ret = -ENOMEM;
622 : 0 : goto error;
623 : : }
624 : 0 : memset(models, 0, sizeof(models[0]) * conf->nb_models);
625 : 0 : dev->data->models = models;
626 : : }
627 : 0 : dev->data->nb_models = conf->nb_models;
628 : :
629 [ # # ]: 0 : if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_PCI) {
630 : 0 : ret = cn10k_ml_dev_configure(cnxk_mldev, conf);
631 [ # # ]: 0 : if (ret != 0) {
632 : 0 : plt_err("Failed to configure CN10K ML Device");
633 : 0 : goto error;
634 : : }
635 : : }
636 : :
637 : : /* Set device capabilities */
638 [ # # ]: 0 : if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_PCI)
639 : 0 : cnxk_mldev->max_mrvl_layers =
640 : 0 : cnxk_mldev->cn10k_mldev.fw.req->cn10k_req.jd.fw_load.cap.s.max_models;
641 : : else
642 : 0 : cnxk_mldev->max_mrvl_layers = 0;
643 : :
644 : 0 : cnxk_mldev->mldev->enqueue_burst = cnxk_ml_enqueue_burst;
645 : 0 : cnxk_mldev->mldev->dequeue_burst = cnxk_ml_dequeue_burst;
646 : 0 : cnxk_mldev->mldev->op_error_get = cnxk_ml_op_error_get;
647 : :
648 : : /* Allocate and initialize index_map */
649 [ # # # # ]: 0 : if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_PCI && cnxk_mldev->index_map == NULL) {
650 : 0 : cnxk_mldev->index_map =
651 : 0 : rte_zmalloc("cnxk_ml_index_map",
652 : 0 : sizeof(struct cnxk_ml_index_map) * cnxk_mldev->max_mrvl_layers,
653 : : RTE_CACHE_LINE_SIZE);
654 [ # # ]: 0 : if (cnxk_mldev->index_map == NULL) {
655 : 0 : plt_err("Failed to get memory for index_map, nb_mrvl_layers %" PRIu64,
656 : : cnxk_mldev->max_mrvl_layers);
657 : : ret = -ENOMEM;
658 : 0 : goto error;
659 : : }
660 : : }
661 : :
662 [ # # ]: 0 : for (i = 0; i < cnxk_mldev->max_mrvl_layers; i++)
663 : 0 : cnxk_mldev->index_map[i].active = false;
664 : :
665 : : /* Initialize xstats */
666 : 0 : ret = cnxk_ml_xstats_init(cnxk_mldev);
667 [ # # ]: 0 : if (ret != 0) {
668 : 0 : plt_err("Failed to initialize xstats");
669 : 0 : goto error;
670 : : }
671 : :
672 : 0 : cnxk_mldev->nb_models_loaded = 0;
673 : 0 : cnxk_mldev->nb_models_started = 0;
674 : 0 : cnxk_mldev->nb_models_stopped = 0;
675 : 0 : cnxk_mldev->nb_models_unloaded = 0;
676 : 0 : cnxk_mldev->state = ML_CNXK_DEV_STATE_CONFIGURED;
677 : :
678 : 0 : return 0;
679 : :
680 : 0 : error:
681 : 0 : rte_free(dev->data->queue_pairs);
682 : 0 : rte_free(dev->data->models);
683 : :
684 : 0 : return ret;
685 : : }
686 : :
687 : : static int
688 : 0 : cnxk_ml_dev_close(struct rte_ml_dev *dev)
689 : : {
690 : : struct cnxk_ml_dev *cnxk_mldev;
691 : : struct cnxk_ml_model *model;
692 : : struct cnxk_ml_qp *qp;
693 : : uint16_t model_id;
694 : : uint16_t qp_id;
695 : :
696 [ # # ]: 0 : if (dev == NULL)
697 : : return -EINVAL;
698 : :
699 : 0 : cnxk_mldev = dev->data->dev_private;
700 : :
701 : : /* Un-initialize xstats */
702 : : cnxk_ml_xstats_uninit(cnxk_mldev);
703 : :
704 [ # # ]: 0 : if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_PCI) {
705 [ # # ]: 0 : if (cn10k_ml_dev_close(cnxk_mldev) != 0)
706 : 0 : plt_err("Failed to close CN10K ML Device");
707 : : }
708 : :
709 : 0 : rte_free(cnxk_mldev->index_map);
710 : :
711 : : /* Stop and unload all models */
712 [ # # ]: 0 : for (model_id = 0; model_id < dev->data->nb_models; model_id++) {
713 : 0 : model = dev->data->models[model_id];
714 [ # # ]: 0 : if (model != NULL) {
715 [ # # ]: 0 : if (model->state == ML_CNXK_MODEL_STATE_STARTED) {
716 [ # # ]: 0 : if (cnxk_ml_model_stop(dev, model_id) != 0)
717 : 0 : plt_err("Could not stop model %u", model_id);
718 : : }
719 [ # # ]: 0 : if (model->state == ML_CNXK_MODEL_STATE_LOADED) {
720 [ # # ]: 0 : if (cnxk_ml_model_unload(dev, model_id) != 0)
721 : 0 : plt_err("Could not unload model %u", model_id);
722 : : }
723 : 0 : dev->data->models[model_id] = NULL;
724 : : }
725 : : }
726 : :
727 : 0 : rte_free(dev->data->models);
728 : :
729 : : /* Destroy all queue pairs */
730 [ # # ]: 0 : for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
731 : 0 : qp = dev->data->queue_pairs[qp_id];
732 [ # # ]: 0 : if (qp != NULL) {
733 [ # # ]: 0 : if (cnxk_ml_qp_destroy(dev, qp) != 0)
734 : 0 : plt_err("Could not destroy queue pair %u", qp_id);
735 : 0 : dev->data->queue_pairs[qp_id] = NULL;
736 : : }
737 : : }
738 : :
739 : 0 : rte_free(dev->data->queue_pairs);
740 : :
741 : 0 : cnxk_mldev->state = ML_CNXK_DEV_STATE_CLOSED;
742 : :
743 : : /* Remove PCI device */
744 : 0 : return rte_dev_remove(dev->device);
745 : : }
746 : :
747 : : static int
748 : 0 : cnxk_ml_dev_start(struct rte_ml_dev *dev)
749 : : {
750 : : struct cnxk_ml_dev *cnxk_mldev;
751 : : int ret;
752 : :
753 [ # # ]: 0 : if (dev == NULL)
754 : : return -EINVAL;
755 : :
756 : 0 : cnxk_mldev = dev->data->dev_private;
757 : :
758 [ # # ]: 0 : if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_PCI) {
759 : 0 : ret = cn10k_ml_dev_start(cnxk_mldev);
760 [ # # ]: 0 : if (ret != 0) {
761 : 0 : plt_err("Failed to start CN10K ML Device");
762 : 0 : return ret;
763 : : }
764 : : }
765 : :
766 : 0 : cnxk_mldev->state = ML_CNXK_DEV_STATE_STARTED;
767 : :
768 : 0 : return 0;
769 : : }
770 : :
771 : : static int
772 : 0 : cnxk_ml_dev_stop(struct rte_ml_dev *dev)
773 : : {
774 : : struct cnxk_ml_dev *cnxk_mldev;
775 : : int ret;
776 : :
777 [ # # ]: 0 : if (dev == NULL)
778 : : return -EINVAL;
779 : :
780 : 0 : cnxk_mldev = dev->data->dev_private;
781 : :
782 [ # # ]: 0 : if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_PCI) {
783 : 0 : ret = cn10k_ml_dev_stop(cnxk_mldev);
784 [ # # ]: 0 : if (ret != 0) {
785 : 0 : plt_err("Failed to stop CN10K ML Device");
786 : 0 : return ret;
787 : : }
788 : : }
789 : :
790 : 0 : cnxk_mldev->state = ML_CNXK_DEV_STATE_CONFIGURED;
791 : :
792 : 0 : return 0;
793 : : }
794 : :
795 : : static int
796 : 0 : cnxk_ml_dev_dump(struct rte_ml_dev *dev, FILE *fp)
797 : : {
798 : : struct cnxk_ml_dev *cnxk_mldev;
799 : : struct cnxk_ml_model *model;
800 : : uint16_t model_id;
801 : :
802 [ # # ]: 0 : if ((dev == NULL) || (fp == NULL))
803 : : return -EINVAL;
804 : :
805 : 0 : cnxk_mldev = dev->data->dev_private;
806 : :
807 : : /* Dump model info */
808 [ # # ]: 0 : for (model_id = 0; model_id < cnxk_mldev->mldev->data->nb_models; model_id++) {
809 : 0 : model = cnxk_mldev->mldev->data->models[model_id];
810 [ # # ]: 0 : if (model != NULL)
811 : 0 : cnxk_ml_model_dump(cnxk_mldev, model, fp);
812 : : }
813 : :
814 [ # # ]: 0 : if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_PCI)
815 : 0 : return cn10k_ml_dev_dump(cnxk_mldev, fp);
816 : : else
817 : 0 : return mvtvm_ml_dev_dump(cnxk_mldev, fp);
818 : :
819 : : return 0;
820 : : }
821 : :
822 : : static int
823 : 0 : cnxk_ml_dev_selftest(struct rte_ml_dev *dev)
824 : : {
825 : : struct cnxk_ml_dev *cnxk_mldev;
826 : :
827 [ # # ]: 0 : if (dev == NULL)
828 : : return -EINVAL;
829 : :
830 : 0 : cnxk_mldev = dev->data->dev_private;
831 : :
832 [ # # ]: 0 : if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_VDEV)
833 : : return -ENOTSUP;
834 : :
835 : 0 : return cn10k_ml_dev_selftest(cnxk_mldev);
836 : : }
837 : :
838 : : static int
839 : 0 : cnxk_ml_dev_queue_pair_setup(struct rte_ml_dev *dev, uint16_t queue_pair_id,
840 : : const struct rte_ml_dev_qp_conf *qp_conf, int socket_id)
841 : : {
842 : : struct rte_ml_dev_info dev_info;
843 : : struct cnxk_ml_qp *qp;
844 : : uint32_t nb_desc;
845 : :
846 [ # # ]: 0 : if (queue_pair_id >= dev->data->nb_queue_pairs) {
847 : 0 : plt_err("Queue-pair id = %u (>= max queue pairs supported, %u)", queue_pair_id,
848 : : dev->data->nb_queue_pairs);
849 : 0 : return -EINVAL;
850 : : }
851 : :
852 [ # # ]: 0 : if (dev->data->queue_pairs[queue_pair_id] != NULL)
853 : 0 : cnxk_ml_dev_queue_pair_release(dev, queue_pair_id);
854 : :
855 : 0 : cnxk_ml_dev_info_get(dev, &dev_info);
856 [ # # ]: 0 : if (qp_conf->nb_desc == 0) {
857 : 0 : plt_err("Could not setup queue pair for %u descriptors", qp_conf->nb_desc);
858 : 0 : return -EINVAL;
859 [ # # ]: 0 : } else if (qp_conf->nb_desc > dev_info.max_desc) {
860 : 0 : plt_err("Could not setup queue pair for %u descriptors (> %u)", qp_conf->nb_desc,
861 : : dev_info.max_desc);
862 : 0 : return -EINVAL;
863 : : }
864 : 0 : plt_ml_dbg("Creating queue-pair, queue_pair_id = %u, nb_desc = %u", queue_pair_id,
865 : : qp_conf->nb_desc);
866 : :
867 : : /* As the number of usable descriptors is 1 less than the queue size being created, we
868 : : * increment the size of queue by 1 than the requested size, except when the requested size
869 : : * is equal to the maximum possible size.
870 : : */
871 : : nb_desc =
872 [ # # ]: 0 : (qp_conf->nb_desc == dev_info.max_desc) ? dev_info.max_desc : qp_conf->nb_desc + 1;
873 : 0 : qp = cnxk_ml_qp_create(dev, queue_pair_id, nb_desc, socket_id);
874 [ # # ]: 0 : if (qp == NULL) {
875 : 0 : plt_err("Could not create queue pair %u", queue_pair_id);
876 : 0 : return -ENOMEM;
877 : : }
878 : 0 : dev->data->queue_pairs[queue_pair_id] = qp;
879 : :
880 : 0 : return 0;
881 : : }
882 : :
883 : : static int
884 : 0 : cnxk_ml_dev_stats_get(struct rte_ml_dev *dev, struct rte_ml_dev_stats *stats)
885 : : {
886 : : struct cnxk_ml_qp *qp;
887 : : int qp_id;
888 : :
889 [ # # ]: 0 : for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
890 : 0 : qp = dev->data->queue_pairs[qp_id];
891 : 0 : stats->enqueued_count += qp->stats.enqueued_count;
892 : 0 : stats->dequeued_count += qp->stats.dequeued_count;
893 : 0 : stats->enqueue_err_count += qp->stats.enqueue_err_count;
894 : 0 : stats->dequeue_err_count += qp->stats.dequeue_err_count;
895 : : }
896 : :
897 : 0 : return 0;
898 : : }
899 : :
900 : : static void
901 : 0 : cnxk_ml_dev_stats_reset(struct rte_ml_dev *dev)
902 : : {
903 : : struct cnxk_ml_qp *qp;
904 : : int qp_id;
905 : :
906 [ # # ]: 0 : for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
907 : 0 : qp = dev->data->queue_pairs[qp_id];
908 : 0 : qp->stats.enqueued_count = 0;
909 : 0 : qp->stats.dequeued_count = 0;
910 : 0 : qp->stats.enqueue_err_count = 0;
911 : 0 : qp->stats.dequeue_err_count = 0;
912 : : }
913 : 0 : }
914 : :
915 : : static int
916 : 0 : cnxk_ml_dev_xstats_names_get(struct rte_ml_dev *dev, enum rte_ml_dev_xstats_mode mode,
917 : : int32_t model_id, struct rte_ml_dev_xstats_map *xstats_map,
918 : : uint32_t size)
919 : : {
920 : : struct cnxk_ml_xstats_entry *xs;
921 : : struct cnxk_ml_dev *cnxk_mldev;
922 : : struct cnxk_ml_model *model;
923 : : uint32_t xstats_mode_count;
924 : : uint16_t layer_id;
925 : : uint32_t idx = 0;
926 : : uint32_t i;
927 : :
928 [ # # ]: 0 : if (dev == NULL)
929 : : return -EINVAL;
930 : :
931 : 0 : cnxk_mldev = dev->data->dev_private;
932 : : xstats_mode_count = 0;
933 : :
934 [ # # # ]: 0 : switch (mode) {
935 : 0 : case RTE_ML_DEV_XSTATS_DEVICE:
936 : 0 : xstats_mode_count = cnxk_mldev->xstats.count_mode_device;
937 : 0 : break;
938 : 0 : case RTE_ML_DEV_XSTATS_MODEL:
939 [ # # ]: 0 : if (model_id >= ML_CNXK_MAX_MODELS)
940 : : break;
941 : :
942 : 0 : model = cnxk_mldev->mldev->data->models[model_id];
943 [ # # ]: 0 : for (layer_id = 0; layer_id < model->nb_layers; layer_id++) {
944 [ # # ]: 0 : if (model->layer[layer_id].type == ML_CNXK_LAYER_TYPE_MRVL)
945 : 0 : xstats_mode_count +=
946 : 0 : cnxk_mldev->xstats.count_per_layer[model_id][layer_id];
947 : : }
948 : :
949 [ # # ]: 0 : if ((model->type == ML_CNXK_MODEL_TYPE_TVM) &&
950 [ # # ]: 0 : (model->subtype != ML_CNXK_MODEL_SUBTYPE_TVM_MRVL))
951 : 0 : xstats_mode_count += RTE_DIM(model_xstats);
952 : : break;
953 : : default:
954 : : return -EINVAL;
955 : : };
956 : :
957 [ # # ]: 0 : if (xstats_mode_count > size || xstats_map == NULL)
958 : 0 : return xstats_mode_count;
959 : :
960 [ # # # # ]: 0 : for (i = 0; i < cnxk_mldev->xstats.count && idx < size; i++) {
961 : 0 : xs = &cnxk_mldev->xstats.entries[i];
962 [ # # ]: 0 : if (xs->mode != mode)
963 : 0 : continue;
964 : :
965 [ # # ]: 0 : if (mode == RTE_ML_DEV_XSTATS_MODEL) {
966 [ # # ]: 0 : if (model_id != xs->obj_idx)
967 : 0 : continue;
968 : :
969 : 0 : model = cnxk_mldev->mldev->data->models[model_id];
970 [ # # ]: 0 : if ((model->type == ML_CNXK_MODEL_TYPE_GLOW ||
971 [ # # ]: 0 : model->subtype == ML_CNXK_MODEL_SUBTYPE_TVM_MRVL) &&
972 [ # # ]: 0 : xs->group == CNXK_ML_XSTATS_GROUP_MODEL)
973 : 0 : continue;
974 : :
975 [ # # ]: 0 : if (model->type == ML_CNXK_MODEL_TYPE_TVM &&
976 [ # # ]: 0 : model->layer[xs->layer_id].type == ML_CNXK_LAYER_TYPE_LLVM)
977 : 0 : continue;
978 : : }
979 : :
980 : 0 : rte_strscpy(xstats_map[idx].name, xs->map.name, RTE_ML_STR_MAX);
981 : 0 : xstats_map[idx].id = xs->map.id;
982 : 0 : idx++;
983 : : }
984 : :
985 : 0 : return idx;
986 : : }
987 : :
988 : : static int
989 : 0 : cnxk_ml_dev_xstats_by_name_get(struct rte_ml_dev *dev, const char *name, uint16_t *stat_id,
990 : : uint64_t *value)
991 : : {
992 : : struct cnxk_ml_xstats_entry *xs;
993 : : struct cnxk_ml_dev *cnxk_mldev;
994 : : cnxk_ml_xstats_fn fn;
995 : : uint32_t i;
996 : :
997 [ # # ]: 0 : if (dev == NULL)
998 : : return -EINVAL;
999 : :
1000 : 0 : cnxk_mldev = dev->data->dev_private;
1001 : :
1002 [ # # ]: 0 : for (i = 0; i < cnxk_mldev->xstats.count; i++) {
1003 : 0 : xs = &cnxk_mldev->xstats.entries[i];
1004 [ # # ]: 0 : if (strncmp(xs->map.name, name, RTE_ML_STR_MAX) == 0) {
1005 [ # # ]: 0 : if (stat_id != NULL)
1006 : 0 : *stat_id = xs->map.id;
1007 : :
1008 [ # # # ]: 0 : switch (xs->fn_id) {
1009 : : case CNXK_ML_XSTATS_FN_DEVICE:
1010 : : fn = cnxk_ml_dev_xstat_get;
1011 : : break;
1012 : 0 : case CNXK_ML_XSTATS_FN_MODEL:
1013 : : fn = cnxk_ml_model_xstat_get;
1014 : 0 : break;
1015 : 0 : default:
1016 : 0 : plt_err("Unexpected xstat fn_id = %d", xs->fn_id);
1017 : 0 : return -EINVAL;
1018 : : }
1019 : :
1020 : 0 : *value = fn(cnxk_mldev, xs->obj_idx, xs->layer_id, xs->type) -
1021 : 0 : xs->reset_value;
1022 : :
1023 : 0 : return 0;
1024 : : }
1025 : : }
1026 : :
1027 [ # # ]: 0 : if (stat_id != NULL)
1028 : 0 : *stat_id = (uint16_t)-1;
1029 : :
1030 : : return -EINVAL;
1031 : : }
1032 : :
1033 : : static int
1034 : 0 : cnxk_ml_dev_xstats_get(struct rte_ml_dev *dev, enum rte_ml_dev_xstats_mode mode, int32_t model_id,
1035 : : const uint16_t stat_ids[], uint64_t values[], uint16_t nb_ids)
1036 : : {
1037 : : struct cnxk_ml_xstats_entry *xs;
1038 : : struct cnxk_ml_dev *cnxk_mldev;
1039 : : struct cnxk_ml_model *model;
1040 : : uint32_t xstats_mode_count;
1041 : : cnxk_ml_xstats_fn fn;
1042 : : uint16_t layer_id;
1043 : : uint64_t val;
1044 : : uint32_t idx;
1045 : : uint32_t i;
1046 : :
1047 [ # # ]: 0 : if (dev == NULL)
1048 : : return -EINVAL;
1049 : :
1050 : 0 : cnxk_mldev = dev->data->dev_private;
1051 : : xstats_mode_count = 0;
1052 : :
1053 [ # # # ]: 0 : switch (mode) {
1054 : 0 : case RTE_ML_DEV_XSTATS_DEVICE:
1055 : 0 : xstats_mode_count = cnxk_mldev->xstats.count_mode_device;
1056 : 0 : break;
1057 : 0 : case RTE_ML_DEV_XSTATS_MODEL:
1058 [ # # ]: 0 : if (model_id >= ML_CNXK_MAX_MODELS)
1059 : : return -EINVAL;
1060 : :
1061 : 0 : model = cnxk_mldev->mldev->data->models[model_id];
1062 [ # # ]: 0 : for (layer_id = 0; layer_id < model->nb_layers; layer_id++)
1063 : 0 : xstats_mode_count += cnxk_mldev->xstats.count_per_layer[model_id][layer_id];
1064 : :
1065 [ # # ]: 0 : if ((model->type == ML_CNXK_MODEL_TYPE_TVM) &&
1066 [ # # ]: 0 : (model->subtype != ML_CNXK_MODEL_SUBTYPE_TVM_MRVL))
1067 : 0 : xstats_mode_count += RTE_DIM(model_xstats);
1068 : : break;
1069 : : default:
1070 : : return -EINVAL;
1071 : : };
1072 : :
1073 : : idx = 0;
1074 [ # # # # ]: 0 : for (i = 0; i < nb_ids && idx < xstats_mode_count; i++) {
1075 : 0 : xs = &cnxk_mldev->xstats.entries[stat_ids[i]];
1076 [ # # # # ]: 0 : if (stat_ids[i] > cnxk_mldev->xstats.count || xs->mode != mode)
1077 : 0 : continue;
1078 : :
1079 [ # # ]: 0 : if (mode == RTE_ML_DEV_XSTATS_MODEL) {
1080 [ # # ]: 0 : if (model_id != xs->obj_idx)
1081 : 0 : continue;
1082 : :
1083 : 0 : model = cnxk_mldev->mldev->data->models[xs->obj_idx];
1084 [ # # ]: 0 : if ((model->type == ML_CNXK_MODEL_TYPE_GLOW ||
1085 [ # # ]: 0 : model->subtype == ML_CNXK_MODEL_SUBTYPE_TVM_MRVL) &&
1086 [ # # ]: 0 : xs->group == CNXK_ML_XSTATS_GROUP_MODEL)
1087 : 0 : continue;
1088 : :
1089 [ # # # # ]: 0 : if (xs->layer_id == -1 && xs->group == CNXK_ML_XSTATS_GROUP_LAYER)
1090 : 0 : continue;
1091 : : }
1092 : :
1093 [ # # # ]: 0 : switch (xs->fn_id) {
1094 : : case CNXK_ML_XSTATS_FN_DEVICE:
1095 : : fn = cnxk_ml_dev_xstat_get;
1096 : : break;
1097 : 0 : case CNXK_ML_XSTATS_FN_MODEL:
1098 : : fn = cnxk_ml_model_xstat_get;
1099 : 0 : break;
1100 : 0 : default:
1101 : 0 : plt_err("Unexpected xstat fn_id = %d", xs->fn_id);
1102 : 0 : return -EINVAL;
1103 : : }
1104 : :
1105 : 0 : val = fn(cnxk_mldev, xs->obj_idx, xs->layer_id, xs->type);
1106 [ # # ]: 0 : if (values)
1107 : 0 : values[idx] = val;
1108 : :
1109 : 0 : idx++;
1110 : : }
1111 : :
1112 : 0 : return idx;
1113 : : }
1114 : :
1115 : : static int
1116 : 0 : cnxk_ml_dev_xstats_reset(struct rte_ml_dev *dev, enum rte_ml_dev_xstats_mode mode, int32_t model_id,
1117 : : const uint16_t stat_ids[], uint16_t nb_ids)
1118 : : {
1119 : : struct cnxk_ml_dev *cnxk_mldev;
1120 : :
1121 [ # # ]: 0 : if (dev == NULL)
1122 : : return -EINVAL;
1123 : :
1124 : 0 : cnxk_mldev = dev->data->dev_private;
1125 : :
1126 [ # # # ]: 0 : switch (mode) {
1127 : 0 : case RTE_ML_DEV_XSTATS_DEVICE:
1128 : 0 : return cnxk_ml_device_xstats_reset(cnxk_mldev, stat_ids, nb_ids);
1129 : 0 : case RTE_ML_DEV_XSTATS_MODEL:
1130 : 0 : return cnxk_ml_model_xstats_reset(cnxk_mldev, model_id, stat_ids, nb_ids);
1131 : : };
1132 : :
1133 : : return 0;
1134 : : }
1135 : :
1136 : : static int
1137 : 0 : cnxk_ml_model_load(struct rte_ml_dev *dev, struct rte_ml_model_params *params, uint16_t *model_id)
1138 : : {
1139 : : struct rte_ml_dev_info dev_info;
1140 : : struct cnxk_ml_dev *cnxk_mldev;
1141 : : enum cnxk_ml_model_type type;
1142 : : struct cnxk_ml_model *model;
1143 : :
1144 : : char str[RTE_MEMZONE_NAMESIZE];
1145 : : const struct plt_memzone *mz;
1146 : : uint16_t max_scratch_pages;
1147 : : struct cn10k_ml_ocm *ocm;
1148 : : uint64_t model_info_size;
1149 : : uint16_t total_wb_pages;
1150 : : uint16_t lcl_model_id;
1151 : : uint16_t layer_id;
1152 : : uint64_t mz_size;
1153 : : bool found;
1154 : : int ret;
1155 : :
1156 [ # # ]: 0 : if (dev == NULL)
1157 : : return -EINVAL;
1158 : :
1159 : 0 : cnxk_mldev = dev->data->dev_private;
1160 : :
1161 : 0 : type = cnxk_ml_model_get_type(params);
1162 [ # # ]: 0 : if (type == ML_CNXK_MODEL_TYPE_INVALID) {
1163 : 0 : plt_err("Invalid / unsupported model type");
1164 : 0 : return -EINVAL;
1165 : : }
1166 : :
1167 [ # # # # ]: 0 : if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_VDEV && type != ML_CNXK_MODEL_TYPE_TVM) {
1168 : 0 : plt_err("Unsupported model type");
1169 : 0 : return -ENOTSUP;
1170 : : }
1171 : :
1172 : : /* Find model ID */
1173 : : found = false;
1174 [ # # ]: 0 : for (lcl_model_id = 0; lcl_model_id < dev->data->nb_models; lcl_model_id++) {
1175 [ # # ]: 0 : if (dev->data->models[lcl_model_id] == NULL) {
1176 : : found = true;
1177 : : break;
1178 : : }
1179 : : }
1180 : :
1181 [ # # ]: 0 : if (!found) {
1182 : 0 : plt_err("No slots available to load new model");
1183 : 0 : return -ENOMEM;
1184 : : }
1185 : :
1186 : : /* Compute memzone size */
1187 : 0 : cnxk_ml_dev_info_get(dev, &dev_info);
1188 : 0 : mz_size = PLT_ALIGN_CEIL(sizeof(struct cnxk_ml_model), dev_info.align_size);
1189 : : model_info_size = sizeof(struct rte_ml_model_info) +
1190 : : ML_CNXK_MODEL_MAX_INPUT_OUTPUT * sizeof(struct rte_ml_io_info) +
1191 : : ML_CNXK_MODEL_MAX_INPUT_OUTPUT * sizeof(struct rte_ml_io_info);
1192 : 0 : model_info_size = PLT_ALIGN_CEIL(model_info_size, dev_info.align_size);
1193 : 0 : mz_size += model_info_size;
1194 : :
1195 : : /* Allocate memzone for model object */
1196 : 0 : snprintf(str, RTE_MEMZONE_NAMESIZE, "%s_%u", CNXK_ML_MODEL_MEMZONE_NAME, lcl_model_id);
1197 : 0 : mz = plt_memzone_reserve_aligned(str, mz_size, 0, dev_info.align_size);
1198 [ # # ]: 0 : if (!mz) {
1199 : 0 : plt_err("Failed to allocate memory for cnxk_ml_model: %s", str);
1200 : 0 : return -ENOMEM;
1201 : : }
1202 : :
1203 : 0 : model = mz->addr;
1204 : 0 : model->cnxk_mldev = cnxk_mldev;
1205 : 0 : model->type = type;
1206 : 0 : model->model_id = lcl_model_id;
1207 : 0 : model->info = PLT_PTR_ADD(
1208 : : model, PLT_ALIGN_CEIL(sizeof(struct cnxk_ml_model), dev_info.align_size));
1209 : 0 : dev->data->models[lcl_model_id] = model;
1210 : :
1211 [ # # ]: 0 : if (type == ML_CNXK_MODEL_TYPE_GLOW)
1212 : 0 : ret = cn10k_ml_model_load(cnxk_mldev, params, model);
1213 : : else
1214 : 0 : ret = tvmrt_ml_model_load(cnxk_mldev, params, model);
1215 [ # # ]: 0 : if (ret != 0)
1216 : 0 : goto error;
1217 : :
1218 : : max_scratch_pages = 0;
1219 : : total_wb_pages = 0;
1220 : : layer_id = 0;
1221 : :
1222 : : ocm = &cnxk_mldev->cn10k_mldev.ocm;
1223 : :
1224 [ # # ]: 0 : if (model->type == ML_CNXK_MODEL_TYPE_GLOW) {
1225 : 0 : total_wb_pages = total_wb_pages + model->layer[layer_id].glow.ocm_map.wb_pages;
1226 : 0 : max_scratch_pages = PLT_MAX(max_scratch_pages,
1227 : : model->layer[layer_id].glow.ocm_map.scratch_pages);
1228 : : #ifdef RTE_MLDEV_CNXK_ENABLE_TVMRT
1229 : : } else {
1230 : : for (layer_id = 0; layer_id < model->nb_layers; layer_id++) {
1231 : : if (model->layer[layer_id].type == ML_CNXK_LAYER_TYPE_MRVL) {
1232 : : total_wb_pages = total_wb_pages +
1233 : : model->layer[layer_id].glow.ocm_map.wb_pages;
1234 : : max_scratch_pages =
1235 : : PLT_MAX(max_scratch_pages,
1236 : : model->layer[layer_id].glow.ocm_map.scratch_pages);
1237 : : }
1238 : : }
1239 : : #endif
1240 : : }
1241 : :
1242 [ # # ]: 0 : if ((total_wb_pages + max_scratch_pages) > ocm->num_pages) {
1243 : 0 : plt_err("model_id = %u: total_wb_pages (%u) + scratch_pages (%u) > %u",
1244 : : lcl_model_id, total_wb_pages, max_scratch_pages, ocm->num_pages);
1245 : :
1246 [ # # ]: 0 : if (model->type == ML_CNXK_MODEL_TYPE_GLOW) {
1247 : 0 : plt_ml_dbg("layer_id = %u: wb_pages = %u, scratch_pages = %u", layer_id,
1248 : : model->layer[layer_id].glow.ocm_map.wb_pages,
1249 : : model->layer[layer_id].glow.ocm_map.scratch_pages);
1250 : : #ifdef RTE_MLDEV_CNXK_ENABLE_TVMRT
1251 : : } else {
1252 : : for (layer_id = 0; layer_id < model->nb_layers; layer_id++) {
1253 : : if (model->layer[layer_id].type == ML_CNXK_LAYER_TYPE_MRVL) {
1254 : : plt_ml_dbg(
1255 : : "layer_id = %u: wb_pages = %u, scratch_pages = %u",
1256 : : layer_id,
1257 : : model->layer[layer_id].glow.ocm_map.wb_pages,
1258 : : model->layer[layer_id].glow.ocm_map.scratch_pages);
1259 : : }
1260 : : }
1261 : : #endif
1262 : : }
1263 : :
1264 [ # # ]: 0 : if (model->type == ML_CNXK_MODEL_TYPE_GLOW)
1265 : 0 : cn10k_ml_model_unload(cnxk_mldev, model);
1266 : : #ifdef RTE_MLDEV_CNXK_ENABLE_TVMRT
1267 : : else {
1268 : : tvmrt_ml_model_unload(cnxk_mldev, model);
1269 : : return -ENOMEM;
1270 : : }
1271 : : #endif
1272 : : }
1273 : : plt_spinlock_init(&model->lock);
1274 : 0 : model->state = ML_CNXK_MODEL_STATE_LOADED;
1275 : 0 : cnxk_mldev->nb_models_loaded++;
1276 : :
1277 : 0 : *model_id = lcl_model_id;
1278 : :
1279 : 0 : return 0;
1280 : :
1281 : : error:
1282 : 0 : rte_memzone_free(mz);
1283 : :
1284 : 0 : return ret;
1285 : : }
1286 : :
1287 : : int
1288 : 0 : cnxk_ml_model_unload(struct rte_ml_dev *dev, uint16_t model_id)
1289 : : {
1290 : : struct cnxk_ml_dev *cnxk_mldev;
1291 : : struct cnxk_ml_model *model;
1292 : :
1293 : : char str[RTE_MEMZONE_NAMESIZE];
1294 : : int ret = 0;
1295 : :
1296 [ # # ]: 0 : if (dev == NULL)
1297 : : return -EINVAL;
1298 : :
1299 : 0 : cnxk_mldev = dev->data->dev_private;
1300 : :
1301 : 0 : model = dev->data->models[model_id];
1302 [ # # ]: 0 : if (model == NULL) {
1303 : 0 : plt_err("Invalid model_id = %u", model_id);
1304 : 0 : return -EINVAL;
1305 : : }
1306 : :
1307 [ # # ]: 0 : if (model->state != ML_CNXK_MODEL_STATE_LOADED) {
1308 : 0 : plt_err("Cannot unload. Model in use.");
1309 : 0 : return -EBUSY;
1310 : : }
1311 : :
1312 [ # # ]: 0 : if (model->type == ML_CNXK_MODEL_TYPE_GLOW)
1313 : 0 : ret = cn10k_ml_model_unload(cnxk_mldev, model);
1314 : : else
1315 : 0 : ret = tvmrt_ml_model_unload(cnxk_mldev, model);
1316 [ # # ]: 0 : if (ret != 0)
1317 : : return ret;
1318 : :
1319 : 0 : dev->data->models[model_id] = NULL;
1320 : 0 : cnxk_mldev->nb_models_unloaded++;
1321 : :
1322 : 0 : snprintf(str, RTE_MEMZONE_NAMESIZE, "%s_%u", CNXK_ML_MODEL_MEMZONE_NAME, model_id);
1323 : 0 : return plt_memzone_free(plt_memzone_lookup(str));
1324 : : }
1325 : :
1326 : : static int
1327 : 0 : cnxk_ml_model_start(struct rte_ml_dev *dev, uint16_t model_id)
1328 : : {
1329 : : struct cnxk_ml_dev *cnxk_mldev;
1330 : : struct cnxk_ml_model *model;
1331 : :
1332 [ # # ]: 0 : if (dev == NULL)
1333 : : return -EINVAL;
1334 : :
1335 : 0 : cnxk_mldev = dev->data->dev_private;
1336 : :
1337 : 0 : model = dev->data->models[model_id];
1338 [ # # ]: 0 : if (model == NULL) {
1339 : 0 : plt_err("Invalid model_id = %u", model_id);
1340 : 0 : return -EINVAL;
1341 : : }
1342 : :
1343 [ # # ]: 0 : if (model->type == ML_CNXK_MODEL_TYPE_GLOW)
1344 : 0 : return cn10k_ml_model_start(cnxk_mldev, model);
1345 : : else
1346 : 0 : return tvmrt_ml_model_start(cnxk_mldev, model);
1347 : :
1348 : : return 0;
1349 : : }
1350 : :
1351 : : int
1352 : 0 : cnxk_ml_model_stop(struct rte_ml_dev *dev, uint16_t model_id)
1353 : : {
1354 : : struct cnxk_ml_dev *cnxk_mldev;
1355 : : struct cnxk_ml_model *model;
1356 : :
1357 [ # # ]: 0 : if (dev == NULL)
1358 : : return -EINVAL;
1359 : :
1360 : 0 : cnxk_mldev = dev->data->dev_private;
1361 : :
1362 : 0 : model = dev->data->models[model_id];
1363 [ # # ]: 0 : if (model == NULL) {
1364 : 0 : plt_err("Invalid model_id = %u", model_id);
1365 : 0 : return -EINVAL;
1366 : : }
1367 : :
1368 [ # # ]: 0 : if (model->type == ML_CNXK_MODEL_TYPE_GLOW)
1369 : 0 : return cn10k_ml_model_stop(cnxk_mldev, model);
1370 : : else
1371 : 0 : return tvmrt_ml_model_stop(cnxk_mldev, model);
1372 : :
1373 : : return 0;
1374 : : }
1375 : :
1376 : : static int
1377 : 0 : cnxk_ml_model_info_get(struct rte_ml_dev *dev, uint16_t model_id,
1378 : : struct rte_ml_model_info *model_info)
1379 : : {
1380 : : struct rte_ml_model_info *info;
1381 : : struct cnxk_ml_model *model;
1382 : :
1383 [ # # ]: 0 : if ((dev == NULL) || (model_info == NULL))
1384 : : return -EINVAL;
1385 : :
1386 : 0 : model = dev->data->models[model_id];
1387 [ # # ]: 0 : if (model == NULL) {
1388 : 0 : plt_err("Invalid model_id = %u", model_id);
1389 : 0 : return -EINVAL;
1390 : : }
1391 : :
1392 : 0 : info = (struct rte_ml_model_info *)model->info;
1393 : 0 : *model_info = *info;
1394 : 0 : model_info->input_info = info->input_info;
1395 : 0 : model_info->output_info = info->output_info;
1396 : :
1397 : 0 : return 0;
1398 : : }
1399 : :
1400 : : static int
1401 : 0 : cnxk_ml_model_params_update(struct rte_ml_dev *dev, uint16_t model_id, void *buffer)
1402 : : {
1403 : : struct cnxk_ml_dev *cnxk_mldev;
1404 : : struct cnxk_ml_model *model;
1405 : :
1406 [ # # ]: 0 : if ((dev == NULL) || (buffer == NULL))
1407 : : return -EINVAL;
1408 : :
1409 : 0 : cnxk_mldev = dev->data->dev_private;
1410 [ # # ]: 0 : if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_VDEV)
1411 : : return -ENOTSUP;
1412 : :
1413 : 0 : model = dev->data->models[model_id];
1414 [ # # ]: 0 : if (model == NULL) {
1415 : 0 : plt_err("Invalid model_id = %u", model_id);
1416 : 0 : return -EINVAL;
1417 : : }
1418 : :
1419 : 0 : return cn10k_ml_model_params_update(cnxk_mldev, model, buffer);
1420 : : }
1421 : :
1422 : : static int
1423 : 0 : cnxk_ml_io_quantize(struct rte_ml_dev *dev, uint16_t model_id, struct rte_ml_buff_seg **dbuffer,
1424 : : struct rte_ml_buff_seg **qbuffer)
1425 : : {
1426 : : struct cnxk_ml_io_info *info = NULL;
1427 : : struct cnxk_ml_model *model;
1428 : : uint8_t *lcl_dbuffer;
1429 : : uint8_t *lcl_qbuffer;
1430 : : uint64_t d_offset;
1431 : : uint64_t q_offset;
1432 : : uint32_t i;
1433 : : int ret;
1434 : :
1435 [ # # # # ]: 0 : if ((dev == NULL) || (dbuffer == NULL) || (qbuffer == NULL))
1436 : : return -EINVAL;
1437 : :
1438 : 0 : model = dev->data->models[model_id];
1439 [ # # ]: 0 : if (model == NULL) {
1440 : 0 : plt_err("Invalid model_id = %u", model_id);
1441 : 0 : return -EINVAL;
1442 : : }
1443 : :
1444 [ # # ]: 0 : if (model->type == ML_CNXK_MODEL_TYPE_GLOW)
1445 : 0 : info = cn10k_ml_model_io_info_get(model, 0);
1446 : : else
1447 : 0 : info = tvmrt_ml_model_io_info_get(model, 0);
1448 : :
1449 [ # # ]: 0 : if (info == NULL)
1450 : : return -EINVAL;
1451 : :
1452 : : d_offset = 0;
1453 : : q_offset = 0;
1454 [ # # ]: 0 : for (i = 0; i < info->nb_inputs; i++) {
1455 [ # # ]: 0 : if (model->type == ML_CNXK_MODEL_TYPE_TVM &&
1456 [ # # ]: 0 : model->subtype != ML_CNXK_MODEL_SUBTYPE_TVM_MRVL) {
1457 : 0 : lcl_dbuffer = dbuffer[i]->addr;
1458 : 0 : lcl_qbuffer = qbuffer[i]->addr;
1459 : : } else {
1460 : 0 : lcl_dbuffer = RTE_PTR_ADD(dbuffer[0]->addr, d_offset);
1461 : 0 : lcl_qbuffer = RTE_PTR_ADD(qbuffer[0]->addr, q_offset);
1462 : : }
1463 : :
1464 : 0 : ret = cnxk_ml_io_quantize_single(&info->input[i], lcl_dbuffer, lcl_qbuffer);
1465 [ # # ]: 0 : if (ret < 0)
1466 : 0 : return ret;
1467 : :
1468 [ # # ]: 0 : if ((model->type == ML_CNXK_MODEL_TYPE_GLOW) ||
1469 [ # # ]: 0 : (model->subtype == ML_CNXK_MODEL_SUBTYPE_TVM_MRVL)) {
1470 : 0 : d_offset += info->input[i].sz_d;
1471 : 0 : q_offset += info->input[i].sz_q;
1472 : : }
1473 : : }
1474 : :
1475 : : return 0;
1476 : : }
1477 : :
1478 : : static int
1479 : 0 : cnxk_ml_io_dequantize(struct rte_ml_dev *dev, uint16_t model_id, struct rte_ml_buff_seg **qbuffer,
1480 : : struct rte_ml_buff_seg **dbuffer)
1481 : : {
1482 : : struct cnxk_ml_io_info *info = NULL;
1483 : : struct cnxk_ml_model *model;
1484 : : uint8_t *lcl_qbuffer;
1485 : : uint8_t *lcl_dbuffer;
1486 : : uint64_t q_offset;
1487 : : uint64_t d_offset;
1488 : : uint32_t i;
1489 : : int ret;
1490 : :
1491 [ # # # # ]: 0 : if ((dev == NULL) || (qbuffer == NULL) || (dbuffer == NULL))
1492 : : return -EINVAL;
1493 : :
1494 : 0 : model = dev->data->models[model_id];
1495 [ # # ]: 0 : if (model == NULL) {
1496 : 0 : plt_err("Invalid model_id = %u", model_id);
1497 : 0 : return -EINVAL;
1498 : : }
1499 : :
1500 [ # # ]: 0 : if (model->type == ML_CNXK_MODEL_TYPE_GLOW)
1501 : 0 : info = cn10k_ml_model_io_info_get(model, model->nb_layers - 1);
1502 : : else
1503 : 0 : info = tvmrt_ml_model_io_info_get(model, model->nb_layers - 1);
1504 : :
1505 [ # # ]: 0 : if (info == NULL)
1506 : : return -EINVAL;
1507 : :
1508 : : q_offset = 0;
1509 : : d_offset = 0;
1510 [ # # ]: 0 : for (i = 0; i < info->nb_outputs; i++) {
1511 [ # # ]: 0 : if (model->type == ML_CNXK_MODEL_TYPE_TVM &&
1512 [ # # ]: 0 : model->subtype != ML_CNXK_MODEL_SUBTYPE_TVM_MRVL) {
1513 : 0 : lcl_qbuffer = qbuffer[i]->addr;
1514 : 0 : lcl_dbuffer = dbuffer[i]->addr;
1515 : : } else {
1516 : 0 : lcl_qbuffer = RTE_PTR_ADD(qbuffer[0]->addr, q_offset);
1517 : 0 : lcl_dbuffer = RTE_PTR_ADD(dbuffer[0]->addr, d_offset);
1518 : : }
1519 : :
1520 : 0 : ret = cnxk_ml_io_dequantize_single(&info->output[i], lcl_qbuffer, lcl_dbuffer);
1521 [ # # ]: 0 : if (ret < 0)
1522 : 0 : return ret;
1523 : :
1524 [ # # ]: 0 : if ((model->type == ML_CNXK_MODEL_TYPE_GLOW) ||
1525 [ # # ]: 0 : (model->subtype == ML_CNXK_MODEL_SUBTYPE_TVM_MRVL)) {
1526 : 0 : q_offset += info->output[i].sz_q;
1527 : 0 : d_offset += info->output[i].sz_d;
1528 : : }
1529 : : }
1530 : :
1531 : : return 0;
1532 : : }
1533 : :
1534 : : static __rte_always_inline void
1535 : : queue_index_advance(uint64_t *index, uint64_t nb_desc)
1536 : : {
1537 : 0 : *index = (*index + 1) % nb_desc;
1538 : : }
1539 : :
1540 : : static __rte_always_inline uint64_t
1541 : : queue_pending_count(uint64_t head, uint64_t tail, uint64_t nb_desc)
1542 : : {
1543 : 0 : return (nb_desc + head - tail) % nb_desc;
1544 : : }
1545 : :
1546 : : static __rte_always_inline uint64_t
1547 : : queue_free_count(uint64_t head, uint64_t tail, uint64_t nb_desc)
1548 : : {
1549 : 0 : return nb_desc - queue_pending_count(head, tail, nb_desc) - 1;
1550 : : }
1551 : :
1552 : : __rte_hot uint16_t
1553 : 0 : cnxk_ml_enqueue_burst(struct rte_ml_dev *dev, uint16_t qp_id, struct rte_ml_op **ops,
1554 : : uint16_t nb_ops)
1555 : : {
1556 : : struct cnxk_ml_dev *cnxk_mldev;
1557 : : struct cnxk_ml_model *model;
1558 : : struct cnxk_ml_queue *queue;
1559 : : struct cnxk_ml_qp *qp;
1560 : : struct rte_ml_op *op;
1561 : :
1562 : : uint16_t layer_id = 0;
1563 : : uint16_t count;
1564 : : uint64_t head;
1565 : :
1566 : 0 : cnxk_mldev = dev->data->dev_private;
1567 : 0 : qp = dev->data->queue_pairs[qp_id];
1568 : : queue = &qp->queue;
1569 : :
1570 : 0 : head = queue->head;
1571 : 0 : nb_ops = PLT_MIN(nb_ops, queue_free_count(head, queue->tail, qp->nb_desc));
1572 : : count = 0;
1573 : :
1574 [ # # ]: 0 : if (unlikely(nb_ops == 0))
1575 : : return 0;
1576 : :
1577 : 0 : enqueue_req:
1578 : 0 : op = ops[count];
1579 : 0 : model = cnxk_mldev->mldev->data->models[op->model_id];
1580 : :
1581 [ # # ]: 0 : if (unlikely(!model->enqueue_single(cnxk_mldev, op, layer_id, qp, head)))
1582 : 0 : goto jcmdq_full;
1583 : :
1584 : 0 : queue_index_advance(&head, qp->nb_desc);
1585 : 0 : count++;
1586 : :
1587 [ # # ]: 0 : if (count < nb_ops)
1588 : 0 : goto enqueue_req;
1589 : :
1590 : 0 : jcmdq_full:
1591 : 0 : queue->head = head;
1592 : 0 : qp->stats.enqueued_count += count;
1593 : : rte_wmb();
1594 : :
1595 : 0 : return count;
1596 : : }
1597 : :
1598 : : __rte_hot uint16_t
1599 : 0 : cnxk_ml_dequeue_burst(struct rte_ml_dev *dev, uint16_t qp_id, struct rte_ml_op **ops,
1600 : : uint16_t nb_ops)
1601 : : {
1602 : : struct cnxk_ml_dev *cnxk_mldev;
1603 : : struct cnxk_ml_queue *queue;
1604 : : struct cnxk_ml_model *model;
1605 : : struct cnxk_ml_req *req;
1606 : : struct cnxk_ml_qp *qp;
1607 : :
1608 : : uint64_t status;
1609 : : uint16_t count;
1610 : : uint64_t tail;
1611 : :
1612 : 0 : cnxk_mldev = dev->data->dev_private;
1613 : 0 : qp = dev->data->queue_pairs[qp_id];
1614 : : queue = &qp->queue;
1615 : :
1616 : 0 : tail = queue->tail;
1617 : 0 : nb_ops = PLT_MIN(nb_ops, queue_pending_count(queue->head, tail, qp->nb_desc));
1618 : : count = 0;
1619 : :
1620 [ # # ]: 0 : if (unlikely(nb_ops == 0))
1621 : 0 : goto empty_or_active;
1622 : :
1623 : 0 : dequeue_req:
1624 : :
1625 : 0 : req = &queue->reqs[tail];
1626 : 0 : model = cnxk_mldev->mldev->data->models[req->op->model_id];
1627 : :
1628 : 0 : status = cnxk_ml_get_poll_ptr(req);
1629 [ # # ]: 0 : if (unlikely(status != ML_CNXK_POLL_JOB_FINISH)) {
1630 [ # # ]: 0 : if (plt_tsc_cycles() < req->timeout)
1631 : 0 : goto empty_or_active;
1632 : : else /* Timeout, set indication of driver error */
1633 : 0 : model->set_error_code(req, ML_CN10K_ETYPE_DRIVER, 0);
1634 : : }
1635 : :
1636 : 0 : model->result_update(cnxk_mldev, qp->id, req);
1637 : :
1638 : 0 : ops[count] = req->op;
1639 : 0 : queue_index_advance(&tail, qp->nb_desc);
1640 : 0 : count++;
1641 : :
1642 [ # # ]: 0 : if (count < nb_ops)
1643 : 0 : goto dequeue_req;
1644 : :
1645 : 0 : empty_or_active:
1646 : 0 : queue->tail = tail;
1647 : :
1648 : 0 : return count;
1649 : : }
1650 : :
1651 : : __rte_hot int
1652 : 0 : cnxk_ml_op_error_get(struct rte_ml_dev *dev, struct rte_ml_op *op, struct rte_ml_op_error *error)
1653 : : {
1654 : : struct cnxk_ml_dev *cnxk_mldev;
1655 : : struct cnxk_ml_model *model;
1656 : :
1657 : 0 : cnxk_mldev = dev->data->dev_private;
1658 : 0 : model = cnxk_mldev->mldev->data->models[op->model_id];
1659 : :
1660 : 0 : return model->op_error_get(cnxk_mldev, op, error);
1661 : : }
1662 : :
1663 : : struct rte_ml_dev_ops cnxk_ml_ops = {
1664 : : /* Device control ops */
1665 : : .dev_info_get = cnxk_ml_dev_info_get,
1666 : : .dev_configure = cnxk_ml_dev_configure,
1667 : : .dev_close = cnxk_ml_dev_close,
1668 : : .dev_start = cnxk_ml_dev_start,
1669 : : .dev_stop = cnxk_ml_dev_stop,
1670 : : .dev_dump = cnxk_ml_dev_dump,
1671 : : .dev_selftest = cnxk_ml_dev_selftest,
1672 : :
1673 : : /* Queue-pair handling ops */
1674 : : .dev_queue_pair_setup = cnxk_ml_dev_queue_pair_setup,
1675 : : .dev_queue_pair_release = cnxk_ml_dev_queue_pair_release,
1676 : :
1677 : : /* Stats ops */
1678 : : .dev_stats_get = cnxk_ml_dev_stats_get,
1679 : : .dev_stats_reset = cnxk_ml_dev_stats_reset,
1680 : : .dev_xstats_names_get = cnxk_ml_dev_xstats_names_get,
1681 : : .dev_xstats_by_name_get = cnxk_ml_dev_xstats_by_name_get,
1682 : : .dev_xstats_get = cnxk_ml_dev_xstats_get,
1683 : : .dev_xstats_reset = cnxk_ml_dev_xstats_reset,
1684 : :
1685 : : /* Model ops */
1686 : : .model_load = cnxk_ml_model_load,
1687 : : .model_unload = cnxk_ml_model_unload,
1688 : : .model_start = cnxk_ml_model_start,
1689 : : .model_stop = cnxk_ml_model_stop,
1690 : : .model_info_get = cnxk_ml_model_info_get,
1691 : : .model_params_update = cnxk_ml_model_params_update,
1692 : :
1693 : : /* I/O ops */
1694 : : .io_quantize = cnxk_ml_io_quantize,
1695 : : .io_dequantize = cnxk_ml_io_dequantize,
1696 : : };
|
