Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (c) 2022 Marvell.
3 : : */
4 : :
5 : : #include <rte_errno.h>
6 : : #include <rte_log.h>
7 : : #include <rte_mldev.h>
8 : : #include <rte_mldev_pmd.h>
9 : :
10 : : #include <stdlib.h>
11 : :
12 : : static struct rte_ml_dev_global ml_dev_globals = {
13 : : .devs = NULL, .data = NULL, .nb_devs = 0, .max_devs = RTE_MLDEV_DEFAULT_MAX};
14 : :
15 : : /*
16 : : * Private data structure of an operation pool.
17 : : *
18 : : * A structure that contains ml op_pool specific data that is
19 : : * appended after the mempool structure (in private data).
20 : : */
21 : : struct rte_ml_op_pool_private {
22 : : uint16_t user_size;
23 : : /*< Size of private user data with each operation. */
24 : : };
25 : :
26 : : struct rte_ml_dev *
27 : 0 : rte_ml_dev_pmd_get_dev(int16_t dev_id)
28 : : {
29 : 0 : return &ml_dev_globals.devs[dev_id];
30 : : }
31 : :
32 : : struct rte_ml_dev *
33 : 0 : rte_ml_dev_pmd_get_named_dev(const char *name)
34 : : {
35 : : struct rte_ml_dev *dev;
36 : : int16_t dev_id;
37 : :
38 [ # # ]: 0 : if (name == NULL)
39 : : return NULL;
40 : :
41 [ # # ]: 0 : for (dev_id = 0; dev_id < ml_dev_globals.max_devs; dev_id++) {
42 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
43 [ # # # # ]: 0 : if ((dev->attached == ML_DEV_ATTACHED) && (strcmp(dev->data->name, name) == 0))
44 : 0 : return dev;
45 : : }
46 : :
47 : : return NULL;
48 : : }
49 : :
50 : : struct rte_ml_dev *
51 : 0 : rte_ml_dev_pmd_allocate(const char *name, uint8_t socket_id)
52 : : {
53 : : char mz_name[RTE_MEMZONE_NAMESIZE];
54 : : const struct rte_memzone *mz;
55 : : struct rte_ml_dev *dev;
56 : : int16_t dev_id;
57 : :
58 : : /* implicit initialization of library before adding first device */
59 [ # # ]: 0 : if (ml_dev_globals.devs == NULL) {
60 [ # # ]: 0 : if (rte_ml_dev_init(RTE_MLDEV_DEFAULT_MAX) != 0)
61 : : return NULL;
62 : : }
63 : :
64 [ # # ]: 0 : if (rte_ml_dev_pmd_get_named_dev(name) != NULL) {
65 : 0 : RTE_MLDEV_LOG(ERR, "ML device with name %s already allocated!", name);
66 : 0 : return NULL;
67 : : }
68 : :
69 : : /* Get a free device ID */
70 [ # # ]: 0 : for (dev_id = 0; dev_id < ml_dev_globals.max_devs; dev_id++) {
71 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
72 [ # # ]: 0 : if (dev->attached == ML_DEV_DETACHED)
73 : : break;
74 : : }
75 : :
76 [ # # ]: 0 : if (dev_id == ml_dev_globals.max_devs) {
77 : 0 : RTE_MLDEV_LOG(ERR, "Reached maximum number of ML devices");
78 : 0 : return NULL;
79 : : }
80 : :
81 [ # # ]: 0 : if (dev->data == NULL) {
82 : : /* Reserve memzone name */
83 : : sprintf(mz_name, "rte_ml_dev_data_%d", dev_id);
84 [ # # ]: 0 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
85 : 0 : mz = rte_memzone_reserve(mz_name, sizeof(struct rte_ml_dev_data), socket_id,
86 : : 0);
87 : 0 : RTE_MLDEV_LOG(DEBUG, "PRIMARY: reserved memzone for %s (%p)", mz_name, mz);
88 : : } else {
89 : 0 : mz = rte_memzone_lookup(mz_name);
90 : 0 : RTE_MLDEV_LOG(DEBUG, "SECONDARY: looked up memzone for %s (%p)", mz_name,
91 : : mz);
92 : : }
93 : :
94 [ # # ]: 0 : if (mz == NULL)
95 : : return NULL;
96 : :
97 : 0 : ml_dev_globals.data[dev_id] = mz->addr;
98 [ # # ]: 0 : if (rte_eal_process_type() == RTE_PROC_PRIMARY)
99 : 0 : memset(ml_dev_globals.data[dev_id], 0, sizeof(struct rte_ml_dev_data));
100 : :
101 : 0 : dev->data = ml_dev_globals.data[dev_id];
102 [ # # ]: 0 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
103 : 0 : strlcpy(dev->data->name, name, RTE_ML_STR_MAX);
104 : 0 : dev->data->dev_id = dev_id;
105 : 0 : dev->data->socket_id = socket_id;
106 : 0 : dev->data->dev_started = 0;
107 : 0 : RTE_MLDEV_LOG(DEBUG, "PRIMARY: init mldev data");
108 : : }
109 : :
110 : 0 : RTE_MLDEV_LOG(DEBUG, "Data for %s: dev_id %d, socket %u", dev->data->name,
111 : : dev->data->dev_id, dev->data->socket_id);
112 : :
113 : 0 : dev->attached = ML_DEV_ATTACHED;
114 : 0 : ml_dev_globals.nb_devs++;
115 : : }
116 : :
117 : 0 : dev->enqueue_burst = NULL;
118 : 0 : dev->dequeue_burst = NULL;
119 : :
120 : 0 : return dev;
121 : : }
122 : :
123 : : int
124 : 0 : rte_ml_dev_pmd_release(struct rte_ml_dev *dev)
125 : : {
126 : : char mz_name[RTE_MEMZONE_NAMESIZE];
127 : : const struct rte_memzone *mz;
128 : : int16_t dev_id;
129 : : int ret = 0;
130 : :
131 [ # # ]: 0 : if (dev == NULL)
132 : : return -EINVAL;
133 : :
134 : 0 : dev_id = dev->data->dev_id;
135 : :
136 : : /* Memzone lookup */
137 : 0 : sprintf(mz_name, "rte_ml_dev_data_%d", dev_id);
138 : 0 : mz = rte_memzone_lookup(mz_name);
139 [ # # ]: 0 : if (mz == NULL)
140 : : return -ENOMEM;
141 : :
142 : : RTE_ASSERT(ml_dev_globals.data[dev_id] == mz->addr);
143 : 0 : ml_dev_globals.data[dev_id] = NULL;
144 : :
145 [ # # ]: 0 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
146 : 0 : RTE_MLDEV_LOG(DEBUG, "PRIMARY: free memzone of %s (%p)", mz_name, mz);
147 : 0 : ret = rte_memzone_free(mz);
148 : : } else {
149 : 0 : RTE_MLDEV_LOG(DEBUG, "SECONDARY: don't free memzone of %s (%p)", mz_name, mz);
150 : : }
151 : :
152 : 0 : dev->attached = ML_DEV_DETACHED;
153 : 0 : ml_dev_globals.nb_devs--;
154 : :
155 : 0 : return ret;
156 : : }
157 : :
158 : : int
159 : 0 : rte_ml_dev_init(size_t dev_max)
160 : : {
161 [ # # ]: 0 : if (dev_max == 0 || dev_max > INT16_MAX) {
162 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_max = %zu (> %d)", dev_max, INT16_MAX);
163 : 0 : rte_errno = EINVAL;
164 : 0 : return -rte_errno;
165 : : }
166 : :
167 : : /* No lock, it must be called before or during first probing. */
168 [ # # ]: 0 : if (ml_dev_globals.devs != NULL) {
169 : 0 : RTE_MLDEV_LOG(ERR, "Device array already initialized");
170 : 0 : rte_errno = EBUSY;
171 : 0 : return -rte_errno;
172 : : }
173 : :
174 : 0 : ml_dev_globals.devs = calloc(dev_max, sizeof(struct rte_ml_dev));
175 [ # # ]: 0 : if (ml_dev_globals.devs == NULL) {
176 : 0 : RTE_MLDEV_LOG(ERR, "Cannot initialize MLDEV library");
177 : 0 : rte_errno = ENOMEM;
178 : 0 : return -rte_errno;
179 : : }
180 : :
181 : 0 : ml_dev_globals.data = calloc(dev_max, sizeof(struct rte_ml_dev_data *));
182 [ # # ]: 0 : if (ml_dev_globals.data == NULL) {
183 : 0 : RTE_MLDEV_LOG(ERR, "Cannot initialize MLDEV library");
184 : 0 : rte_errno = ENOMEM;
185 : 0 : return -rte_errno;
186 : : }
187 : :
188 : 0 : ml_dev_globals.max_devs = dev_max;
189 : :
190 : 0 : return 0;
191 : : }
192 : :
193 : : uint16_t
194 : 0 : rte_ml_dev_count(void)
195 : : {
196 : 0 : return ml_dev_globals.nb_devs;
197 : : }
198 : :
199 : : int
200 : 0 : rte_ml_dev_is_valid_dev(int16_t dev_id)
201 : : {
202 : : struct rte_ml_dev *dev = NULL;
203 : :
204 [ # # # # ]: 0 : if (dev_id >= ml_dev_globals.max_devs || ml_dev_globals.devs[dev_id].data == NULL)
205 : : return 0;
206 : :
207 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
208 [ # # ]: 0 : if (dev->attached != ML_DEV_ATTACHED)
209 : : return 0;
210 : : else
211 : 0 : return 1;
212 : : }
213 : :
214 : : int
215 : 0 : rte_ml_dev_socket_id(int16_t dev_id)
216 : : {
217 : : struct rte_ml_dev *dev;
218 : :
219 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
220 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
221 : 0 : return -EINVAL;
222 : : }
223 : :
224 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
225 : :
226 : 0 : return dev->data->socket_id;
227 : : }
228 : :
229 : : int
230 : 0 : rte_ml_dev_info_get(int16_t dev_id, struct rte_ml_dev_info *dev_info)
231 : : {
232 : : struct rte_ml_dev *dev;
233 : :
234 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
235 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
236 : 0 : return -EINVAL;
237 : : }
238 : :
239 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
240 [ # # ]: 0 : if (*dev->dev_ops->dev_info_get == NULL)
241 : : return -ENOTSUP;
242 : :
243 [ # # ]: 0 : if (dev_info == NULL) {
244 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, dev_info cannot be NULL", dev_id);
245 : 0 : return -EINVAL;
246 : : }
247 : : memset(dev_info, 0, sizeof(struct rte_ml_dev_info));
248 : :
249 : 0 : return (*dev->dev_ops->dev_info_get)(dev, dev_info);
250 : : }
251 : :
252 : : int
253 : 0 : rte_ml_dev_configure(int16_t dev_id, const struct rte_ml_dev_config *config)
254 : : {
255 : : struct rte_ml_dev_info dev_info;
256 : : struct rte_ml_dev *dev;
257 : : int ret;
258 : :
259 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
260 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
261 : 0 : return -EINVAL;
262 : : }
263 : :
264 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
265 [ # # ]: 0 : if (*dev->dev_ops->dev_configure == NULL)
266 : : return -ENOTSUP;
267 : :
268 [ # # ]: 0 : if (dev->data->dev_started) {
269 : 0 : RTE_MLDEV_LOG(ERR, "Device %d must be stopped to allow configuration", dev_id);
270 : 0 : return -EBUSY;
271 : : }
272 : :
273 [ # # ]: 0 : if (config == NULL) {
274 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, config cannot be NULL", dev_id);
275 : 0 : return -EINVAL;
276 : : }
277 : :
278 : 0 : ret = rte_ml_dev_info_get(dev_id, &dev_info);
279 [ # # ]: 0 : if (ret < 0)
280 : : return ret;
281 : :
282 [ # # ]: 0 : if (config->nb_queue_pairs > dev_info.max_queue_pairs) {
283 : 0 : RTE_MLDEV_LOG(ERR, "Device %d num of queues %u > %u", dev_id,
284 : : config->nb_queue_pairs, dev_info.max_queue_pairs);
285 : 0 : return -EINVAL;
286 : : }
287 : :
288 : 0 : return (*dev->dev_ops->dev_configure)(dev, config);
289 : : }
290 : :
291 : : int
292 : 0 : rte_ml_dev_close(int16_t dev_id)
293 : : {
294 : : struct rte_ml_dev *dev;
295 : :
296 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
297 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
298 : 0 : return -EINVAL;
299 : : }
300 : :
301 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
302 [ # # ]: 0 : if (*dev->dev_ops->dev_close == NULL)
303 : : return -ENOTSUP;
304 : :
305 : : /* Device must be stopped before it can be closed */
306 [ # # ]: 0 : if (dev->data->dev_started == 1) {
307 : 0 : RTE_MLDEV_LOG(ERR, "Device %d must be stopped before closing", dev_id);
308 : 0 : return -EBUSY;
309 : : }
310 : :
311 : 0 : return (*dev->dev_ops->dev_close)(dev);
312 : : }
313 : :
314 : : int
315 : 0 : rte_ml_dev_start(int16_t dev_id)
316 : : {
317 : : struct rte_ml_dev *dev;
318 : : int ret;
319 : :
320 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
321 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
322 : 0 : return -EINVAL;
323 : : }
324 : :
325 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
326 [ # # ]: 0 : if (*dev->dev_ops->dev_start == NULL)
327 : : return -ENOTSUP;
328 : :
329 [ # # ]: 0 : if (dev->data->dev_started != 0) {
330 : 0 : RTE_MLDEV_LOG(ERR, "Device %d is already started", dev_id);
331 : 0 : return -EBUSY;
332 : : }
333 : :
334 : 0 : ret = (*dev->dev_ops->dev_start)(dev);
335 [ # # ]: 0 : if (ret == 0)
336 : 0 : dev->data->dev_started = 1;
337 : :
338 : : return ret;
339 : : }
340 : :
341 : : int
342 : 0 : rte_ml_dev_stop(int16_t dev_id)
343 : : {
344 : : struct rte_ml_dev *dev;
345 : : int ret;
346 : :
347 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
348 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
349 : 0 : return -EINVAL;
350 : : }
351 : :
352 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
353 [ # # ]: 0 : if (*dev->dev_ops->dev_stop == NULL)
354 : : return -ENOTSUP;
355 : :
356 [ # # ]: 0 : if (dev->data->dev_started == 0) {
357 : 0 : RTE_MLDEV_LOG(ERR, "Device %d is not started", dev_id);
358 : 0 : return -EBUSY;
359 : : }
360 : :
361 : 0 : ret = (*dev->dev_ops->dev_stop)(dev);
362 [ # # ]: 0 : if (ret == 0)
363 : 0 : dev->data->dev_started = 0;
364 : :
365 : : return ret;
366 : : }
367 : :
368 : : int
369 : 0 : rte_ml_dev_queue_pair_setup(int16_t dev_id, uint16_t queue_pair_id,
370 : : const struct rte_ml_dev_qp_conf *qp_conf, int socket_id)
371 : : {
372 : : struct rte_ml_dev *dev;
373 : :
374 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
375 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
376 : 0 : return -EINVAL;
377 : : }
378 : :
379 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
380 [ # # ]: 0 : if (*dev->dev_ops->dev_queue_pair_setup == NULL)
381 : : return -ENOTSUP;
382 : :
383 [ # # ]: 0 : if (queue_pair_id >= dev->data->nb_queue_pairs) {
384 : 0 : RTE_MLDEV_LOG(ERR, "Invalid queue_pair_id = %d", queue_pair_id);
385 : 0 : return -EINVAL;
386 : : }
387 : :
388 [ # # ]: 0 : if (qp_conf == NULL) {
389 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, qp_conf cannot be NULL", dev_id);
390 : 0 : return -EINVAL;
391 : : }
392 : :
393 [ # # ]: 0 : if (dev->data->dev_started) {
394 : 0 : RTE_MLDEV_LOG(ERR, "Device %d must be stopped to allow configuration", dev_id);
395 : 0 : return -EBUSY;
396 : : }
397 : :
398 : 0 : return (*dev->dev_ops->dev_queue_pair_setup)(dev, queue_pair_id, qp_conf, socket_id);
399 : : }
400 : :
401 : : int
402 : 0 : rte_ml_dev_stats_get(int16_t dev_id, struct rte_ml_dev_stats *stats)
403 : : {
404 : : struct rte_ml_dev *dev;
405 : :
406 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
407 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
408 : 0 : return -EINVAL;
409 : : }
410 : :
411 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
412 [ # # ]: 0 : if (*dev->dev_ops->dev_stats_get == NULL)
413 : : return -ENOTSUP;
414 : :
415 [ # # ]: 0 : if (stats == NULL) {
416 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, stats cannot be NULL", dev_id);
417 : 0 : return -EINVAL;
418 : : }
419 : : memset(stats, 0, sizeof(struct rte_ml_dev_stats));
420 : :
421 : 0 : return (*dev->dev_ops->dev_stats_get)(dev, stats);
422 : : }
423 : :
424 : : void
425 : 0 : rte_ml_dev_stats_reset(int16_t dev_id)
426 : : {
427 : : struct rte_ml_dev *dev;
428 : :
429 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
430 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
431 : 0 : return;
432 : : }
433 : :
434 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
435 [ # # ]: 0 : if (*dev->dev_ops->dev_stats_reset == NULL)
436 : : return;
437 : :
438 : 0 : (*dev->dev_ops->dev_stats_reset)(dev);
439 : : }
440 : :
441 : : int
442 : 0 : rte_ml_dev_xstats_names_get(int16_t dev_id, enum rte_ml_dev_xstats_mode mode, int32_t model_id,
443 : : struct rte_ml_dev_xstats_map *xstats_map, uint32_t size)
444 : : {
445 : : struct rte_ml_dev *dev;
446 : :
447 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
448 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
449 : 0 : return -EINVAL;
450 : : }
451 : :
452 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
453 [ # # ]: 0 : if (*dev->dev_ops->dev_xstats_names_get == NULL)
454 : : return -ENOTSUP;
455 : :
456 : 0 : return (*dev->dev_ops->dev_xstats_names_get)(dev, mode, model_id, xstats_map, size);
457 : : }
458 : :
459 : : int
460 : 0 : rte_ml_dev_xstats_by_name_get(int16_t dev_id, const char *name, uint16_t *stat_id, uint64_t *value)
461 : : {
462 : : struct rte_ml_dev *dev;
463 : :
464 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
465 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
466 : 0 : return -EINVAL;
467 : : }
468 : :
469 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
470 [ # # ]: 0 : if (*dev->dev_ops->dev_xstats_by_name_get == NULL)
471 : : return -ENOTSUP;
472 : :
473 [ # # ]: 0 : if (name == NULL) {
474 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, name cannot be NULL", dev_id);
475 : 0 : return -EINVAL;
476 : : }
477 : :
478 [ # # ]: 0 : if (value == NULL) {
479 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, value cannot be NULL", dev_id);
480 : 0 : return -EINVAL;
481 : : }
482 : :
483 : 0 : return (*dev->dev_ops->dev_xstats_by_name_get)(dev, name, stat_id, value);
484 : : }
485 : :
486 : : int
487 : 0 : rte_ml_dev_xstats_get(int16_t dev_id, enum rte_ml_dev_xstats_mode mode, int32_t model_id,
488 : : const uint16_t stat_ids[], uint64_t values[], uint16_t nb_ids)
489 : : {
490 : : struct rte_ml_dev *dev;
491 : :
492 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
493 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
494 : 0 : return -EINVAL;
495 : : }
496 : :
497 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
498 [ # # ]: 0 : if (*dev->dev_ops->dev_xstats_get == NULL)
499 : : return -ENOTSUP;
500 : :
501 [ # # ]: 0 : if (stat_ids == NULL) {
502 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, stat_ids cannot be NULL", dev_id);
503 : 0 : return -EINVAL;
504 : : }
505 : :
506 [ # # ]: 0 : if (values == NULL) {
507 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, values cannot be NULL", dev_id);
508 : 0 : return -EINVAL;
509 : : }
510 : :
511 : 0 : return (*dev->dev_ops->dev_xstats_get)(dev, mode, model_id, stat_ids, values, nb_ids);
512 : : }
513 : :
514 : : int
515 : 0 : rte_ml_dev_xstats_reset(int16_t dev_id, enum rte_ml_dev_xstats_mode mode, int32_t model_id,
516 : : const uint16_t stat_ids[], uint16_t nb_ids)
517 : : {
518 : : struct rte_ml_dev *dev;
519 : :
520 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
521 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
522 : 0 : return -EINVAL;
523 : : }
524 : :
525 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
526 [ # # ]: 0 : if (*dev->dev_ops->dev_xstats_reset == NULL)
527 : : return -ENOTSUP;
528 : :
529 : 0 : return (*dev->dev_ops->dev_xstats_reset)(dev, mode, model_id, stat_ids, nb_ids);
530 : : }
531 : :
532 : : int
533 : 0 : rte_ml_dev_dump(int16_t dev_id, FILE *fd)
534 : : {
535 : : struct rte_ml_dev *dev;
536 : :
537 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
538 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
539 : 0 : return -EINVAL;
540 : : }
541 : :
542 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
543 [ # # ]: 0 : if (*dev->dev_ops->dev_dump == NULL)
544 : : return -ENOTSUP;
545 : :
546 [ # # ]: 0 : if (fd == NULL) {
547 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, file descriptor cannot be NULL", dev_id);
548 : 0 : return -EINVAL;
549 : : }
550 : :
551 : 0 : return (*dev->dev_ops->dev_dump)(dev, fd);
552 : : }
553 : :
554 : : int
555 : 0 : rte_ml_dev_selftest(int16_t dev_id)
556 : : {
557 : : struct rte_ml_dev *dev;
558 : :
559 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
560 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
561 : 0 : return -EINVAL;
562 : : }
563 : :
564 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
565 [ # # ]: 0 : if (*dev->dev_ops->dev_selftest == NULL)
566 : : return -ENOTSUP;
567 : :
568 : 0 : return (*dev->dev_ops->dev_selftest)(dev);
569 : : }
570 : :
571 : : int
572 : 0 : rte_ml_model_load(int16_t dev_id, struct rte_ml_model_params *params, uint16_t *model_id)
573 : : {
574 : : struct rte_ml_dev *dev;
575 : :
576 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
577 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
578 : 0 : return -EINVAL;
579 : : }
580 : :
581 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
582 [ # # ]: 0 : if (*dev->dev_ops->model_load == NULL)
583 : : return -ENOTSUP;
584 : :
585 [ # # ]: 0 : if (params == NULL) {
586 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, params cannot be NULL", dev_id);
587 : 0 : return -EINVAL;
588 : : }
589 : :
590 [ # # ]: 0 : if (model_id == NULL) {
591 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, model_id cannot be NULL", dev_id);
592 : 0 : return -EINVAL;
593 : : }
594 : :
595 : 0 : return (*dev->dev_ops->model_load)(dev, params, model_id);
596 : : }
597 : :
598 : : int
599 : 0 : rte_ml_model_unload(int16_t dev_id, uint16_t model_id)
600 : : {
601 : : struct rte_ml_dev *dev;
602 : :
603 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
604 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
605 : 0 : return -EINVAL;
606 : : }
607 : :
608 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
609 [ # # ]: 0 : if (*dev->dev_ops->model_unload == NULL)
610 : : return -ENOTSUP;
611 : :
612 : 0 : return (*dev->dev_ops->model_unload)(dev, model_id);
613 : : }
614 : :
615 : : int
616 : 0 : rte_ml_model_start(int16_t dev_id, uint16_t model_id)
617 : : {
618 : : struct rte_ml_dev *dev;
619 : :
620 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
621 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
622 : 0 : return -EINVAL;
623 : : }
624 : :
625 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
626 [ # # ]: 0 : if (*dev->dev_ops->model_start == NULL)
627 : : return -ENOTSUP;
628 : :
629 : 0 : return (*dev->dev_ops->model_start)(dev, model_id);
630 : : }
631 : :
632 : : int
633 : 0 : rte_ml_model_stop(int16_t dev_id, uint16_t model_id)
634 : : {
635 : : struct rte_ml_dev *dev;
636 : :
637 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
638 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
639 : 0 : return -EINVAL;
640 : : }
641 : :
642 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
643 [ # # ]: 0 : if (*dev->dev_ops->model_stop == NULL)
644 : : return -ENOTSUP;
645 : :
646 : 0 : return (*dev->dev_ops->model_stop)(dev, model_id);
647 : : }
648 : :
649 : : int
650 : 0 : rte_ml_model_info_get(int16_t dev_id, uint16_t model_id, struct rte_ml_model_info *model_info)
651 : : {
652 : : struct rte_ml_dev *dev;
653 : :
654 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
655 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
656 : 0 : return -EINVAL;
657 : : }
658 : :
659 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
660 [ # # ]: 0 : if (*dev->dev_ops->model_info_get == NULL)
661 : : return -ENOTSUP;
662 : :
663 [ # # ]: 0 : if (model_info == NULL) {
664 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, model_id %u, model_info cannot be NULL", dev_id,
665 : : model_id);
666 : 0 : return -EINVAL;
667 : : }
668 : :
669 : 0 : return (*dev->dev_ops->model_info_get)(dev, model_id, model_info);
670 : : }
671 : :
672 : : int
673 : 0 : rte_ml_model_params_update(int16_t dev_id, uint16_t model_id, void *buffer)
674 : : {
675 : : struct rte_ml_dev *dev;
676 : :
677 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
678 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
679 : 0 : return -EINVAL;
680 : : }
681 : :
682 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
683 [ # # ]: 0 : if (*dev->dev_ops->model_params_update == NULL)
684 : : return -ENOTSUP;
685 : :
686 [ # # ]: 0 : if (buffer == NULL) {
687 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, buffer cannot be NULL", dev_id);
688 : 0 : return -EINVAL;
689 : : }
690 : :
691 : 0 : return (*dev->dev_ops->model_params_update)(dev, model_id, buffer);
692 : : }
693 : :
694 : : int
695 : 0 : rte_ml_io_quantize(int16_t dev_id, uint16_t model_id, struct rte_ml_buff_seg **dbuffer,
696 : : struct rte_ml_buff_seg **qbuffer)
697 : : {
698 : : struct rte_ml_dev *dev;
699 : :
700 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
701 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
702 : 0 : return -EINVAL;
703 : : }
704 : :
705 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
706 [ # # ]: 0 : if (*dev->dev_ops->io_quantize == NULL)
707 : : return -ENOTSUP;
708 : :
709 [ # # ]: 0 : if (dbuffer == NULL) {
710 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, dbuffer cannot be NULL", dev_id);
711 : 0 : return -EINVAL;
712 : : }
713 : :
714 [ # # ]: 0 : if (qbuffer == NULL) {
715 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, qbuffer cannot be NULL", dev_id);
716 : 0 : return -EINVAL;
717 : : }
718 : :
719 : 0 : return (*dev->dev_ops->io_quantize)(dev, model_id, dbuffer, qbuffer);
720 : : }
721 : :
722 : : int
723 : 0 : rte_ml_io_dequantize(int16_t dev_id, uint16_t model_id, struct rte_ml_buff_seg **qbuffer,
724 : : struct rte_ml_buff_seg **dbuffer)
725 : : {
726 : : struct rte_ml_dev *dev;
727 : :
728 [ # # ]: 0 : if (!rte_ml_dev_is_valid_dev(dev_id)) {
729 : 0 : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
730 : 0 : return -EINVAL;
731 : : }
732 : :
733 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
734 [ # # ]: 0 : if (*dev->dev_ops->io_dequantize == NULL)
735 : : return -ENOTSUP;
736 : :
737 [ # # ]: 0 : if (qbuffer == NULL) {
738 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, qbuffer cannot be NULL", dev_id);
739 : 0 : return -EINVAL;
740 : : }
741 : :
742 [ # # ]: 0 : if (dbuffer == NULL) {
743 : 0 : RTE_MLDEV_LOG(ERR, "Dev %d, dbuffer cannot be NULL", dev_id);
744 : 0 : return -EINVAL;
745 : : }
746 : :
747 : 0 : return (*dev->dev_ops->io_dequantize)(dev, model_id, qbuffer, dbuffer);
748 : : }
749 : :
750 : : /** Initialise rte_ml_op mempool element */
751 : : static void
752 : 0 : ml_op_init(struct rte_mempool *mempool, __rte_unused void *opaque_arg, void *_op_data,
753 : : __rte_unused unsigned int i)
754 : : {
755 : : struct rte_ml_op *op = _op_data;
756 : :
757 : 0 : memset(_op_data, 0, mempool->elt_size);
758 : 0 : op->status = RTE_ML_OP_STATUS_NOT_PROCESSED;
759 : 0 : op->mempool = mempool;
760 : 0 : }
761 : :
762 : : struct rte_mempool *
763 : 0 : rte_ml_op_pool_create(const char *name, unsigned int nb_elts, unsigned int cache_size,
764 : : uint16_t user_size, int socket_id)
765 : : {
766 : : struct rte_ml_op_pool_private *priv;
767 : : struct rte_mempool *mp;
768 : : unsigned int elt_size;
769 : :
770 : : /* lookup mempool in case already allocated */
771 : 0 : mp = rte_mempool_lookup(name);
772 : 0 : elt_size = sizeof(struct rte_ml_op) + user_size;
773 : :
774 [ # # ]: 0 : if (mp != NULL) {
775 : : priv = (struct rte_ml_op_pool_private *)rte_mempool_get_priv(mp);
776 [ # # # # : 0 : if (mp->elt_size != elt_size || mp->cache_size < cache_size || mp->size < nb_elts ||
# # ]
777 [ # # ]: 0 : priv->user_size < user_size) {
778 : : mp = NULL;
779 : 0 : RTE_MLDEV_LOG(ERR,
780 : : "Mempool %s already exists but with incompatible parameters",
781 : : name);
782 : 0 : return NULL;
783 : : }
784 : : return mp;
785 : : }
786 : :
787 : 0 : mp = rte_mempool_create(name, nb_elts, elt_size, cache_size,
788 : : sizeof(struct rte_ml_op_pool_private), NULL, NULL, ml_op_init, NULL,
789 : : socket_id, 0);
790 [ # # ]: 0 : if (mp == NULL) {
791 : 0 : RTE_MLDEV_LOG(ERR, "Failed to create mempool %s", name);
792 : 0 : return NULL;
793 : : }
794 : :
795 : : priv = (struct rte_ml_op_pool_private *)rte_mempool_get_priv(mp);
796 : 0 : priv->user_size = user_size;
797 : :
798 : 0 : return mp;
799 : : }
800 : :
801 : : void
802 : 0 : rte_ml_op_pool_free(struct rte_mempool *mempool)
803 : : {
804 : 0 : rte_mempool_free(mempool);
805 : 0 : }
806 : :
807 : : uint16_t
808 : 0 : rte_ml_enqueue_burst(int16_t dev_id, uint16_t qp_id, struct rte_ml_op **ops, uint16_t nb_ops)
809 : : {
810 : : struct rte_ml_dev *dev;
811 : :
812 : : #ifdef RTE_LIBRTE_ML_DEV_DEBUG
813 : : if (!rte_ml_dev_is_valid_dev(dev_id)) {
814 : : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
815 : : rte_errno = -EINVAL;
816 : : return 0;
817 : : }
818 : :
819 : : dev = rte_ml_dev_pmd_get_dev(dev_id);
820 : : if (*dev->enqueue_burst == NULL) {
821 : : rte_errno = -ENOTSUP;
822 : : return 0;
823 : : }
824 : :
825 : : if (ops == NULL) {
826 : : RTE_MLDEV_LOG(ERR, "Dev %d, ops cannot be NULL", dev_id);
827 : : rte_errno = -EINVAL;
828 : : return 0;
829 : : }
830 : :
831 : : if (qp_id >= dev->data->nb_queue_pairs) {
832 : : RTE_MLDEV_LOG(ERR, "Invalid qp_id %u", qp_id);
833 : : rte_errno = -EINVAL;
834 : : return 0;
835 : : }
836 : : #else
837 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
838 : : #endif
839 : :
840 : 0 : return (*dev->enqueue_burst)(dev, qp_id, ops, nb_ops);
841 : : }
842 : :
843 : : uint16_t
844 : 0 : rte_ml_dequeue_burst(int16_t dev_id, uint16_t qp_id, struct rte_ml_op **ops, uint16_t nb_ops)
845 : : {
846 : : struct rte_ml_dev *dev;
847 : :
848 : : #ifdef RTE_LIBRTE_ML_DEV_DEBUG
849 : : if (!rte_ml_dev_is_valid_dev(dev_id)) {
850 : : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
851 : : rte_errno = -EINVAL;
852 : : return 0;
853 : : }
854 : :
855 : : dev = rte_ml_dev_pmd_get_dev(dev_id);
856 : : if (*dev->dequeue_burst == NULL) {
857 : : rte_errno = -ENOTSUP;
858 : : return 0;
859 : : }
860 : :
861 : : if (ops == NULL) {
862 : : RTE_MLDEV_LOG(ERR, "Dev %d, ops cannot be NULL", dev_id);
863 : : rte_errno = -EINVAL;
864 : : return 0;
865 : : }
866 : :
867 : : if (qp_id >= dev->data->nb_queue_pairs) {
868 : : RTE_MLDEV_LOG(ERR, "Invalid qp_id %u", qp_id);
869 : : rte_errno = -EINVAL;
870 : : return 0;
871 : : }
872 : : #else
873 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
874 : : #endif
875 : :
876 : 0 : return (*dev->dequeue_burst)(dev, qp_id, ops, nb_ops);
877 : : }
878 : :
879 : : int
880 : 0 : rte_ml_op_error_get(int16_t dev_id, struct rte_ml_op *op, struct rte_ml_op_error *error)
881 : : {
882 : : struct rte_ml_dev *dev;
883 : :
884 : : #ifdef RTE_LIBRTE_ML_DEV_DEBUG
885 : : if (!rte_ml_dev_is_valid_dev(dev_id)) {
886 : : RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d", dev_id);
887 : : return -EINVAL;
888 : : }
889 : :
890 : : dev = rte_ml_dev_pmd_get_dev(dev_id);
891 : : if (*dev->op_error_get == NULL)
892 : : return -ENOTSUP;
893 : :
894 : : if (op == NULL) {
895 : : RTE_MLDEV_LOG(ERR, "Dev %d, op cannot be NULL", dev_id);
896 : : return -EINVAL;
897 : : }
898 : :
899 : : if (error == NULL) {
900 : : RTE_MLDEV_LOG(ERR, "Dev %d, error cannot be NULL", dev_id);
901 : : return -EINVAL;
902 : : }
903 : : #else
904 : 0 : dev = rte_ml_dev_pmd_get_dev(dev_id);
905 : : #endif
906 : :
907 : 0 : return (*dev->op_error_get)(dev, op, error);
908 : : }
909 : :
910 [ - + ]: 238 : RTE_LOG_REGISTER_DEFAULT(rte_ml_dev_logtype, INFO);
|