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