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