From patchwork Tue Feb 7 15:13:05 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 123257 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 0A1AB41C30; Tue, 7 Feb 2023 16:13:39 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id C975E410DF; Tue, 7 Feb 2023 16:13:38 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 38BDD4021F for ; Tue, 7 Feb 2023 16:13:37 +0100 (CET) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 317CFgSm019068; Tue, 7 Feb 2023 07:13:36 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=zpAJy1BhJQSjD0ZBc3j1OBOmS7K65tGaXplo7HnVz5o=; b=gCT0YVZYcXkrRZ0T4xueNkfNRa7NthDHfemmRvAiP7YudJGZbMvPSPDdlgRpO9tMf95Q +h+VFHgIT59Blfdy7dGSRqcKTn69ospDhF8hE64rFSK8+chV0plRuxQnCbMuoaAO3sXo CVzzojxGKRGH/ANyhJgsT2ewLKl8nUAMlhOHNTcxftEPdbSWLnnYij57LNqSs2okAn1Y xYLSjK53eht1J71J2bYpPG4yRaq2iLjzirv/zOebEdZHFGZJDnJ8fQPrQuU8C1wOrsxs 2OWl9kveU1XawSe8hZ5009TzcF3uhlwOpD4vQFy6ug7LeWJIhrv/FiC2Z+GdkJ0vXjbS EQ== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3nhqrtme2t-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Tue, 07 Feb 2023 07:13:35 -0800 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.42; Tue, 7 Feb 2023 07:13:33 -0800 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.42 via Frontend Transport; Tue, 7 Feb 2023 07:13:33 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id 976433F7083; Tue, 7 Feb 2023 07:13:30 -0800 (PST) From: To: , Thomas Monjalon , Srikanth Yalavarthi CC: , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v3 01/12] mldev: introduce machine learning device library Date: Tue, 7 Feb 2023 20:43:05 +0530 Message-ID: <20230207151316.835441-2-jerinj@marvell.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230207151316.835441-1-jerinj@marvell.com> References: <20230206202453.336280-1-jerinj@marvell.com> <20230207151316.835441-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: ptn4dRey33TiS0cI0dWOA4ZM4KoyITLO X-Proofpoint-ORIG-GUID: ptn4dRey33TiS0cI0dWOA4ZM4KoyITLO X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-07_07,2023-02-06_03,2022-06-22_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Jerin Jacob Add mldev API specification to standardize and use the machine learning device and inference operations in vendor neutral way. Following operations are abstracted through APIs - ML device capability probe - ML device configuration - ML device queue pair configuration - ML device state management - ML device stat/xstat operations - ML model load/unload/start/stop operations - ML model information probe - ML IO operations to find size for input and output buffers - ML quantize and dequantize operations - ML ops pool creation and free operations - ML device enqueue/dequeue fastpath interference operations Also added programming guide. Signed-off-by: Jerin Jacob Signed-off-by: Srikanth Yalavarthi --- MAINTAINERS | 5 + doc/api/doxy-api-index.md | 1 + doc/api/doxy-api.conf.in | 1 + doc/guides/prog_guide/img/mldev_flow.svg | 714 ++++++++++++++ doc/guides/prog_guide/index.rst | 1 + doc/guides/prog_guide/mldev.rst | 186 ++++ doc/guides/rel_notes/release_23_03.rst | 5 + lib/meson.build | 1 + lib/mldev/meson.build | 18 + lib/mldev/rte_mldev.c | 8 + lib/mldev/rte_mldev.h | 1119 ++++++++++++++++++++++ lib/mldev/version.map | 7 + 12 files changed, 2066 insertions(+) create mode 100644 doc/guides/prog_guide/img/mldev_flow.svg create mode 100644 doc/guides/prog_guide/mldev.rst create mode 100644 lib/mldev/meson.build create mode 100644 lib/mldev/rte_mldev.c create mode 100644 lib/mldev/rte_mldev.h create mode 100644 lib/mldev/version.map diff --git a/MAINTAINERS b/MAINTAINERS index 3495946d0f..fa91900a20 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -538,6 +538,11 @@ F: drivers/raw/skeleton/ F: app/test/test_rawdev.c F: doc/guides/prog_guide/rawdev.rst +ML device API - EXPERIMENTAL +M: Srikanth Yalavarthi +F: lib/mldev/ +F: doc/guides/prog_guide/mldev.rst + Memory Pool Drivers ------------------- diff --git a/doc/api/doxy-api-index.md b/doc/api/doxy-api-index.md index de488c7abf..a12562977a 100644 --- a/doc/api/doxy-api-index.md +++ b/doc/api/doxy-api-index.md @@ -22,6 +22,7 @@ The public API headers are grouped by topics: [compress](@ref rte_comp.h), [regexdev](@ref rte_regexdev.h), [dmadev](@ref rte_dmadev.h), + [mldev](@ref rte_mldev.h), [eventdev](@ref rte_eventdev.h), [event_eth_rx_adapter](@ref rte_event_eth_rx_adapter.h), [event_eth_tx_adapter](@ref rte_event_eth_tx_adapter.h), diff --git a/doc/api/doxy-api.conf.in b/doc/api/doxy-api.conf.in index f0886c3bd1..5d6416d3e0 100644 --- a/doc/api/doxy-api.conf.in +++ b/doc/api/doxy-api.conf.in @@ -57,6 +57,7 @@ INPUT = @TOPDIR@/doc/api/doxy-api-index.md \ @TOPDIR@/lib/mempool \ @TOPDIR@/lib/meter \ @TOPDIR@/lib/metrics \ + @TOPDIR@/lib/mldev \ @TOPDIR@/lib/node \ @TOPDIR@/lib/net \ @TOPDIR@/lib/pcapng \ diff --git a/doc/guides/prog_guide/img/mldev_flow.svg b/doc/guides/prog_guide/img/mldev_flow.svg new file mode 100644 index 0000000000..6c5dda14e5 --- /dev/null +++ b/doc/guides/prog_guide/img/mldev_flow.svg @@ -0,0 +1,714 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + rte_ml_model_update_params() + + + + rte_ml_model_stop() + + + + rte_ml_model_unload() + + + + rte_ml_model_start() + + + + rte_ml_model_info_get() + + + + rte_ml_model_load() + + + + rte_ml_dequeue_burst() + + + + + + + + + + Queue Pair 0 + + + + Queue Pair .. + + + + Queue Pair N + + + + + + Core 0 + + + + Core .. + + + + Core N + + + + rte_ml_enqueue_burst() + + + + MachineLearningInferenceEngine + + + + + + + Model 0 + + + + Model 1 + + + + Model .. + + + + Model N + + + + mldev + + diff --git a/doc/guides/prog_guide/index.rst b/doc/guides/prog_guide/index.rst index 8564883018..d7f2a28bdb 100644 --- a/doc/guides/prog_guide/index.rst +++ b/doc/guides/prog_guide/index.rst @@ -30,6 +30,7 @@ Programmer's Guide regexdev dmadev gpudev + mldev rte_security rawdev link_bonding_poll_mode_drv_lib diff --git a/doc/guides/prog_guide/mldev.rst b/doc/guides/prog_guide/mldev.rst new file mode 100644 index 0000000000..a0bd370e72 --- /dev/null +++ b/doc/guides/prog_guide/mldev.rst @@ -0,0 +1,186 @@ +.. SPDX-License-Identifier: BSD-3-Clause + Copyright (c) 2022 Marvell. + +Machine Learning Device Library +=============================== + +The MLDEV library provides a Machine Learning device framework for the management and +provisioning of hardware and software ML poll mode drivers, defining APIs which +support a number of ML operations including device handling and inference processing. +The ML model creation and training is outside of the scope of this library. + +The ML framework is built on the following model: + +.. _figure_mldev_work_flow: + +.. figure:: img/mldev_flow.* + + Work flow of inference on MLDEV + +**ML Device**: A hardware or software-based implementation of ML device API for running +inferences using a pre-trained ML model. + +**ML Model**: An ML model is an algorithm trained over a dataset. A model consists of +procedure/algorithm and data/pattern required to make predictions on live data. Once +the model is created and trained outside of the DPDK scope, the model can be loaded +via rte_ml_model_load() and then start it using rte_ml_model_start() API. The +rte_ml_model_params_update() can be used to update the model parameters such as weights +and bias without unloading the model using rte_ml_model_unload(). + +**ML Inference**: ML inference is the process of feeding data to the model via +rte_ml_enqueue_burst() API and use rte_ml_dequeue_burst() API to get the calculated +outputs / predictions from the started model. + +Design Principles +----------------- + +The MLDEV library follows the same basic principles as those used in DPDK's +Ethernet Device framework and the Crypto framework. The MLDEV framework provides +a generic Machine Learning device framework which supports both physical (hardware) +and virtual (software) ML devices as well as an ML API to manage and configure ML +devices. The APIs also supports performing ML inference operations through ML poll +mode driver. + + +Device Operations +----------------- + +Device Creation +~~~~~~~~~~~~~~~ + +Physical ML devices are discovered during the PCI probe/enumeration, through the +EAL functions which are executed at DPDK initialization, based on their PCI device +identifier, each unique PCI BDF (bus/bridge, device, function). ML physical devices, +like other physical devices in DPDK can be white-listed or black-listed +using the EAL command line options. + + +Device Identification +~~~~~~~~~~~~~~~~~~~~~ + +Each device, whether virtual or physical is uniquely designated by two +identifiers: + +- A unique device index used to designate the ML device in all functions + exported by the MLDEV API. + +- A device name used to designate the ML device in console messages, for + administration or debugging purposes. + +Device Features and Capabilities +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +ML devices may support different feature set. In order to get the +supported PMD feature ``rte_ml_dev_info_get`` API which return the +info of the device and it's supported features. + +Device Configuration +~~~~~~~~~~~~~~~~~~~~ + +The configuration of each ML device includes the following operations: + +- Allocation of resources, including hardware resources if a physical device. +- Resetting the device into a well-known default state. +- Initialization of statistics counters. + +The rte_ml_dev_configure API is used to configure a ML device. + +.. code-block:: c + + int rte_ml_dev_configure(int16_t dev_id, const struct rte_ml_dev_config *cfg); + +The ``rte_ml_dev_config`` structure is used to pass the configuration parameters +for the ML device, for example number of queue pairs, maximum number of models, +maximum size of model and so on. + +Configuration of Queue Pairs +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Each ML device can be configured with number of queue pairs. +Each queue pair is configured using ``rte_ml_dev_queue_pair_setup`` + +Logical Cores, Memory and Queues Pair Relationships +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Multiple logical cores should never share the same queue pair for enqueuing +operations or dequeueing operations on the same ML device since this would +require global locks and hinder performance. + +Configuration of Machine Learning models +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Pre-trained ML models that are built using external ML compiler / training frameworks +are used to perform inference operations. These models are configured on an ML device +in a two-stage process that includes loading the model on an ML device, and starting +the model to accept inference operations. Inference operations can be queued for a +model only when the model is in started state. Model load stage assigns a Model ID, +which is unique for the model in a driver's context. Model ID is used during all +subsequent slow-path and fast-path operations. + +Model loading and start is done through the ``rte_ml_model_load`` and +``rte_ml_model_start`` functions. + +Similarly stop and unloading are done through ``rte_ml_model_stop`` and +``rte_ml_model_unload`` functions. + +Stop and unload functions would release the resources allocated for the +models. Inference tasks cannot be queued for a model that is stopped. + +Detailed information related to the model can be retrieved from the driver using the +function ``rte_ml_model_info_get``. Model information is accessible to the application +through the ``rte_ml_model_info`` structure. Information available to the user would +include the details related to the inputs and outputs, and the maximum batch size +supported by the model. + +User can optionally update the model params such as weights and bias, without unloading +the model, through the ``rte_ml_model_params_update`` function. A model should be in +stopped state to update the params. Model has to be started in order to enqueue inference +requests after a params update. + +Enqueue / Dequeue +~~~~~~~~~~~~~~~~~ + +The burst enqueue API uses a ML device identifier and a queue pair identifier +to specify the device queue pair to schedule the processing on. The ``nb_ops`` +parameter is the number of operations to process which are supplied in the +``ops`` array of ``rte_ml_op`` structures. The enqueue function returns the +number of operations it enqueued for processing, a return value equal to +``nb_ops`` means that all packets have been enqueued. + +The dequeue API uses the same format as the enqueue API of processed but +the ``nb_ops`` and ``ops`` parameters are now used to specify the max processed +operations the user wishes to retrieve and the location in which to store them. +The API call returns the actual number of processed operations returned; this +can never be larger than ``nb_ops``. + +``rte_ml_op`` provides the required information to the driver to queue an ML inference +task. ML op specifies the model to be used and the number of batches to be executed in +the inference task. Input and output buffer information is specified through the +structure ``rte_ml_buff_seg``, which supports segmented data. Input is provided through +the ``rte_ml_op::input`` and output through ``rte_ml_op::output``. Data pointed in each +op, should not be released until the dequeue of for that op. + + +Quantize and Dequantize +~~~~~~~~~~~~~~~~~~~~~~~ + +Inference operations performed with lower precision types would improve the throughput +and efficiency of the inference execution with a minimal loss of accuracy, which is within +the tolerance limits. Quantization and dequantization is the process of converting data +from a higher precision type to a lower precision type and vice-versa. ML library provides +the functions ``rte_ml_io_quantize`` and ``rte_ml_io_dequantize`` to enable data type +conversions. User needs to provide the address of the quantized and dequantized data +buffers to the functions, along the number of the batches in the buffers. + +For quantization, the dequantized data is assumed to be of the type ``dtype`` provided by +the ``rte_ml_model_info::input`` and the data is converted to ``qtype`` provided by the +``rte_ml_model_info::input``. + +For dequantization, the quantized data is assumed to be of the type ``qtype`` provided by +the ``rte_ml_model_info::output`` and the data is converted to ``dtype`` provided by the +``rte_ml_model_info::output``. + +Size of the buffers required for the input and output can be calculated using the functions +``rte_ml_io_input_size_get`` and ``rte_ml_io_output_size_get``. These functions would get the +buffer sizes for both quantized and dequantized data for the given number of batches. + diff --git a/doc/guides/rel_notes/release_23_03.rst b/doc/guides/rel_notes/release_23_03.rst index 1fa101c420..f23b58f416 100644 --- a/doc/guides/rel_notes/release_23_03.rst +++ b/doc/guides/rel_notes/release_23_03.rst @@ -87,6 +87,11 @@ New Features ``rte_event_dev_config::nb_single_link_event_port_queues`` parameter required for eth_rx, eth_tx, crypto and timer eventdev adapters. +* **Added machine learning inference device library.** + + * Added a machine learning inference device framework for management and provision of + hardware and software machine learning inference devices. + Removed Items ------------- diff --git a/lib/meson.build b/lib/meson.build index a90fee31b7..ad91819375 100644 --- a/lib/meson.build +++ b/lib/meson.build @@ -63,6 +63,7 @@ libraries = [ 'flow_classify', # flow_classify lib depends on pkt framework table lib 'graph', 'node', + 'mldev', ] optional_libs = [ diff --git a/lib/mldev/meson.build b/lib/mldev/meson.build new file mode 100644 index 0000000000..e378cfca30 --- /dev/null +++ b/lib/mldev/meson.build @@ -0,0 +1,18 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright (c) 2022 Marvell. + +sources = files( + 'rte_mldev.c', +) + +headers = files( + 'rte_mldev.h', +) + +deps += ['mempool'] + +if get_option('buildtype').contains('debug') + cflags += [ '-DRTE_LIBRTE_ML_DEV_DEBUG' ] +else + cflags += [ '-URTE_LIBRTE_ML_DEV_DEBUG' ] +endif diff --git a/lib/mldev/rte_mldev.c b/lib/mldev/rte_mldev.c new file mode 100644 index 0000000000..70aad4c44b --- /dev/null +++ b/lib/mldev/rte_mldev.c @@ -0,0 +1,8 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2022 Marvell. + */ + +#include +#include + +RTE_LOG_REGISTER_DEFAULT(rte_ml_dev_logtype, INFO); diff --git a/lib/mldev/rte_mldev.h b/lib/mldev/rte_mldev.h new file mode 100644 index 0000000000..b22234730d --- /dev/null +++ b/lib/mldev/rte_mldev.h @@ -0,0 +1,1119 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2022 Marvell. + */ + +#ifndef RTE_MLDEV_H +#define RTE_MLDEV_H + +/** + * @file rte_mldev.h + * + * @warning + * @b EXPERIMENTAL: + * All functions in this file may be changed or removed without prior notice. + * + * ML (Machine Learning) device API. + * + * The ML framework is built on the following model: + * + * + * +-----------------+ rte_ml_[en|de]queue_burst() + * | | | + * | Machine o------+ +--------+ | + * | Learning | | | queue | | +------+ + * | Inference o------+-----o |<===o===>|Core 0| + * | Engine | | | pair 0 | +------+ + * | o----+ | +--------+ + * | | | | + * +-----------------+ | | +--------+ + * ^ | | | queue | +------+ + * | | +-----o |<=======>|Core 1| + * | | | pair 1 | +------+ + * | | +--------+ + * +--------+--------+ | + * | +-------------+ | | +--------+ + * | | Model 0 | | | | queue | +------+ + * | +-------------+ | +-------o |<=======>|Core N| + * | +-------------+ | | pair N | +------+ + * | | Model 1 | | +--------+ + * | +-------------+ | + * | +-------------+ |<------> rte_ml_model_load() + * | | Model .. | |-------> rte_ml_model_info_get() + * | +-------------+ |<------- rte_ml_model_start() + * | +-------------+ |<------- rte_ml_model_stop() + * | | Model N | |<------- rte_ml_model_params_update() + * | +-------------+ |<------- rte_ml_model_unload() + * +-----------------+ + * + * ML Device: A hardware or software-based implementation of ML device API for + * running inferences using a pre-trained ML model. + * + * ML Model: An ML model is an algorithm trained over a dataset. A model consists of + * procedure/algorithm and data/pattern required to make predictions on live data. + * Once the model is created and trained outside of the DPDK scope, the model can be loaded + * via rte_ml_model_load() and then start it using rte_ml_model_start() API. + * The rte_ml_model_params_update() can be used to update the model parameters such as weight + * and bias without unloading the model using rte_ml_model_unload(). + * + * ML Inference: ML inference is the process of feeding data to the model via + * rte_ml_enqueue_burst() API and use rte_ml_dequeue_burst() API to get the calculated + * outputs/predictions from the started model. + * + * In all functions of the ML device API, the ML device is designated by an + * integer >= 0 named as device identifier *dev_id*. + * + * The functions exported by the ML device API to setup a device designated by + * its device identifier must be invoked in the following order: + * + * - rte_ml_dev_configure() + * - rte_ml_dev_queue_pair_setup() + * - rte_ml_dev_start() + * + * A model is required to run the inference operations with the user specified inputs. + * Application needs to invoke the ML model API in the following order before queueing + * inference jobs. + * + * - rte_ml_model_load() + * - rte_ml_model_start() + * + * A model can be loaded on a device only after the device has been configured and can be + * started or stopped only after a device has been started. + * + * The rte_ml_model_info_get() API is provided to retrieve the information related to the model. + * The information would include the shape and type of input and output required for the inference. + * + * Data quantization and dequantization is one of the main aspects in ML domain. This involves + * conversion of input data from a higher precision to a lower precision data type and vice-versa + * for the output. APIs are provided to enable quantization through rte_ml_io_quantize() and + * dequantization through rte_ml_io_dequantize(). These APIs have the capability to handle input + * and output buffers holding data for multiple batches. + * + * Two utility APIs rte_ml_io_input_size_get() and rte_ml_io_output_size_get() can used to get the + * size of quantized and de-quantized multi-batch input and output buffers. + * + * User can optionally update the model parameters with rte_ml_model_params_update() after + * invoking rte_ml_model_stop() API on a given model ID. + * + * The application can invoke, in any order, the functions exported by the ML API to enqueue + * inference jobs and dequeue inference response. + * + * If the application wants to change the device configuration (i.e., call + * rte_ml_dev_configure() or rte_ml_dev_queue_pair_setup()), then application must stop the + * device using rte_ml_dev_stop() API. Likewise, if model parameters need to be updated then + * the application must call rte_ml_model_stop() followed by rte_ml_model_params_update() API + * for the given model. The application does not need to call rte_ml_dev_stop() API for + * any model re-configuration such as rte_ml_model_params_update(), rte_ml_model_unload() etc. + * + * Once the device is in the start state after invoking rte_ml_dev_start() API and the model is in + * start state after invoking rte_ml_model_start() API, then the application can call + * rte_ml_enqueue_burst() and rte_ml_dequeue_burst() API on the destined device and model ID. + * + * Finally, an application can close an ML device by invoking the rte_ml_dev_close() function. + * + * Typical application utilisation of the ML API will follow the following + * programming flow. + * + * - rte_ml_dev_configure() + * - rte_ml_dev_queue_pair_setup() + * - rte_ml_model_load() + * - rte_ml_dev_start() + * - rte_ml_model_start() + * - rte_ml_model_info_get() + * - rte_ml_enqueue_burst() + * - rte_ml_dequeue_burst() + * - rte_ml_model_stop() + * - rte_ml_model_unload() + * - rte_ml_dev_stop() + * - rte_ml_dev_close() + * + * Regarding multi-threading, by default, all the functions of the ML Device API exported by a PMD + * are lock-free functions which assume to not be invoked in parallel on different logical cores + * on the same target object. For instance, the dequeue function of a poll mode driver cannot be + * invoked in parallel on two logical cores to operate on same queue pair. Of course, this function + * can be invoked in parallel by different logical core on different queue pair. + * It is the responsibility of the user application to enforce this rule. + */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Logging Macro */ +extern int rte_ml_dev_logtype; + +#define RTE_MLDEV_LOG(level, fmt, args...) \ + rte_log(RTE_LOG_##level, rte_ml_dev_logtype, "%s(): " fmt "\n", __func__, ##args) + +#define RTE_ML_STR_MAX 128 +/**< Maximum length of name string */ + +#define RTE_MLDEV_DEFAULT_MAX 32 +/** Maximum number of devices if rte_ml_dev_init() is not called. */ + +/* Device operations */ + +/** + * Initialize the device array before probing devices. If not called, the first device probed would + * initialize the array to a size of RTE_MLDEV_DEFAULT_MAX. + * + * @param dev_max + * Maximum number of devices. + * + * @return + * 0 on success, -rte_errno otherwise: + * - ENOMEM if out of memory + * - EINVAL if 0 size + * - EBUSY if already initialized + */ +__rte_experimental +int +rte_ml_dev_init(size_t dev_max); + +/** + * Get the total number of ML devices that have been successfully initialised. + * + * @return + * - The total number of usable ML devices. + */ +__rte_experimental +uint16_t +rte_ml_dev_count(void); + +/** + * Check if the device is in ready state. + * + * @param dev_id + * The identifier of the device. + * + * @return + * - 0 if device state is not in ready state. + * - 1 if device state is ready state. + */ +__rte_experimental +int +rte_ml_dev_is_valid_dev(int16_t dev_id); + +/** + * Return the NUMA socket to which a device is connected. + * + * @param dev_id + * The identifier of the device. + * + * @return + * - The NUMA socket id to which the device is connected + * - 0 If the socket could not be determined. + * - -EINVAL: if the dev_id value is not valid. + */ +__rte_experimental +int +rte_ml_dev_socket_id(int16_t dev_id); + +/** ML device information */ +struct rte_ml_dev_info { + const char *driver_name; + /**< Driver name */ + uint16_t max_models; + /**< Maximum number of models supported by the device. + * @see struct rte_ml_dev_config::nb_models + */ + uint16_t max_queue_pairs; + /**< Maximum number of queues pairs supported by the device. + * @see struct rte_ml_dev_config::nb_queue_pairs + */ + uint16_t max_desc; + /**< Maximum allowed number of descriptors for queue pair by the device. + * @see struct rte_ml_dev_qp_conf::nb_desc + */ + uint16_t max_segments; + /**< Maximum number of scatter-gather entries supported by the device. + * @see struct rte_ml_buff_seg struct rte_ml_buff_seg::next + */ + uint16_t min_align_size; + /**< Minimum alignment size of IO buffers used by the device. */ +}; + +/** + * Retrieve the information of the device. + * + * @param dev_id + * The identifier of the device. + * @param dev_info + * A pointer to a structure of type *rte_ml_dev_info* to be filled with the info of the device. + * + * @return + * - 0: Success, driver updates the information of the ML device + * - < 0: Error code returned by the driver info get function. + */ +__rte_experimental +int +rte_ml_dev_info_get(int16_t dev_id, struct rte_ml_dev_info *dev_info); + +/** ML device configuration structure */ +struct rte_ml_dev_config { + int socket_id; + /**< Socket to allocate resources on. */ + uint16_t nb_models; + /**< Number of models to be loaded on the device. + * This value cannot exceed the max_models which is previously provided in + * struct rte_ml_dev_info::max_models + */ + uint16_t nb_queue_pairs; + /**< Number of queue pairs to configure on this device. + * This value cannot exceed the max_models which is previously provided in + * struct rte_ml_dev_info::max_queue_pairs + */ +}; + +/** + * Configure an ML device. + * + * This function must be invoked first before any other function in the API. + * + * ML Device can be re-configured, when in a stopped state. Device cannot be re-configured after + * rte_ml_dev_close() is called. + * + * The caller may use rte_ml_dev_info_get() to get the capability of each resources available for + * this ML device. + * + * @param dev_id + * The identifier of the device to configure. + * @param config + * The ML device configuration structure. + * + * @return + * - 0: Success, device configured. + * - < 0: Error code returned by the driver configuration function. + */ +__rte_experimental +int +rte_ml_dev_configure(int16_t dev_id, const struct rte_ml_dev_config *config); + +/* Forward declaration */ +struct rte_ml_op; + +/**< Callback function called during rte_ml_dev_stop(), invoked once per flushed ML op */ +typedef void (*rte_ml_dev_stop_flush_t)(int16_t dev_id, uint16_t qp_id, struct rte_ml_op *op); + +/** ML device queue pair configuration structure. */ +struct rte_ml_dev_qp_conf { + uint32_t nb_desc; + /**< Number of descriptors per queue pair. + * This value cannot exceed the max_desc which previously provided in + * struct rte_ml_dev_info:max_desc + */ + rte_ml_dev_stop_flush_t cb; + /**< Callback function called during rte_ml_dev_stop(), invoked once per active ML op. + * Value NULL is allowed, in which case callback will not be invoked. + * This function can be used to properly dispose of outstanding ML ops from all + * queue pairs, for example ops containing memory pointers. + * @see rte_ml_dev_stop() + */ +}; + +/** + * Set up a queue pair for a device. This should only be called when the device is stopped. + * + * @param dev_id + * The identifier of the device. + * @param queue_pair_id + * The index of the queue pairs to set up. The value must be in the range [0, nb_queue_pairs - 1] + * previously supplied to rte_ml_dev_configure(). + * @param qp_conf + * The pointer to the configuration data to be used for the queue pair. + * @param socket_id + * The *socket_id* argument is the socket identifier in case of NUMA. + * The value can be *SOCKET_ID_ANY* if there is no NUMA constraint for the memory allocated + * for the queue pair. + * + * @return + * - 0: Success, queue pair correctly set up. + * - < 0: Queue pair configuration failed. + */ +__rte_experimental +int +rte_ml_dev_queue_pair_setup(int16_t dev_id, uint16_t queue_pair_id, + const struct rte_ml_dev_qp_conf *qp_conf, int socket_id); + +/** + * Start an ML device. + * + * The device start step consists of setting the configured features and enabling the ML device + * to accept inference jobs. + * + * @param dev_id + * The identifier of the device. + * + * @return + * - 0: Success, device started. + * - <0: Error code of the driver device start function. + */ +__rte_experimental +int +rte_ml_dev_start(int16_t dev_id); + +/** + * Stop an ML device. A stopped device cannot accept inference jobs. + * The device can be restarted with a call to rte_ml_dev_start(). + * + * @param dev_id + * The identifier of the device. + * + * @return + * - 0: Success, device stopped. + * - <0: Error code of the driver device stop function. + */ +__rte_experimental +int +rte_ml_dev_stop(int16_t dev_id); + +/** + * Close an ML device. The device cannot be restarted! + * + * @param dev_id + * The identifier of the device. + * + * @return + * - 0 on successfully closing device. + * - <0 on failure to close device. + */ +__rte_experimental +int +rte_ml_dev_close(int16_t dev_id); + +/** Status of ML operation */ +enum rte_ml_op_status { + RTE_ML_OP_STATUS_SUCCESS = 0, + /**< Operation completed successfully */ + RTE_ML_OP_STATUS_NOT_PROCESSED, + /**< Operation has not yet been processed by the device. */ + RTE_ML_OP_STATUS_ERROR, + /**< Operation completed with error. + * Application can invoke rte_ml_op_error_get() to get PMD specific + * error code if needed. + */ +}; + +/** ML operation's input and output buffer representation as scatter gather list + */ +struct rte_ml_buff_seg { + rte_iova_t iova_addr; + /**< IOVA address of segment buffer. */ + void *addr; + /**< Virtual address of segment buffer. */ + uint32_t length; + /**< Segment length. */ + uint32_t reserved; + /**< Reserved for future use. */ + struct rte_ml_buff_seg *next; + /**< Points to next segment. Value NULL represents the last segment. */ +}; + +/** + * ML Operation. + * + * This structure contains data related to performing an ML operation on the buffers using + * the model specified through model_id. + */ +struct rte_ml_op { + uint16_t model_id; + /**< Model ID to be used for the operation. */ + uint16_t nb_batches; + /**< Number of batches. Minimum value must be one. + * Input buffer must hold inference data for each batch as contiguous. + */ + uint32_t reserved; + /**< Reserved for future use. */ + struct rte_mempool *mempool; + /**< Pool from which operation is allocated. */ + struct rte_ml_buff_seg input; + /**< Input buffer to hold the inference data. */ + struct rte_ml_buff_seg output; + /**< Output buffer to hold the inference output by the driver. */ + RTE_STD_C11 + union { + uint64_t user_u64; + /**< User data as uint64_t.*/ + void *user_ptr; + /**< User data as void*.*/ + }; + enum rte_ml_op_status status; + /**< Operation status. */ + uint64_t impl_opaque; + /**< Implementation specific opaque value. + * An implementation may use this field to hold + * implementation specific value to share between + * dequeue and enqueue operation. + * The application should not modify this field. + */ +} __rte_cache_aligned; + +/* Enqueue/Dequeue operations */ + +/** + * Enqueue a burst of ML inferences for processing on an ML device. + * + * The rte_ml_enqueue_burst() function is invoked to place ML inference + * operations on the queue *qp_id* of the device designated by its *dev_id*. + * + * The *nb_ops* parameter is the number of inferences to process which are + * supplied in the *ops* array of *rte_ml_op* structures. + * + * The rte_ml_enqueue_burst() function returns the number of inferences it + * actually enqueued for processing. A return value equal to *nb_ops* means that + * all packets have been enqueued. + * + * @param dev_id + * The identifier of the device. + * @param qp_id + * The index of the queue pair which inferences are to be enqueued for processing. + * The value must be in the range [0, nb_queue_pairs - 1] previously supplied to + * *rte_ml_dev_configure*. + * @param ops + * The address of an array of *nb_ops* pointers to *rte_ml_op* structures which contain the + * ML inferences to be processed. + * @param nb_ops + * The number of operations to process. + * + * @return + * The number of inference operations actually enqueued to the ML device. + * The return value can be less than the value of the *nb_ops* parameter when the ML device queue + * is full or if invalid parameters are specified in a *rte_ml_op*. + */ +__rte_experimental +uint16_t +rte_ml_enqueue_burst(int16_t dev_id, uint16_t qp_id, struct rte_ml_op **ops, uint16_t nb_ops); + +/** + * Dequeue a burst of processed ML inferences operations from a queue on the ML device. + * The dequeued operations are stored in *rte_ml_op* structures whose pointers are supplied + * in the *ops* array. + * + * The rte_ml_dequeue_burst() function returns the number of inferences actually dequeued, + * which is the number of *rte_ml_op* data structures effectively supplied into the *ops* array. + * + * A return value equal to *nb_ops* indicates that the queue contained at least nb_ops* operations, + * and this is likely to signify that other processed operations remain in the devices output queue. + * Application implementing a "retrieve as many processed operations as possible" policy can check + * this specific case and keep invoking the rte_ml_dequeue_burst() function until a value less than + * *nb_ops* is returned. + * + * The rte_ml_dequeue_burst() function does not provide any error notification to avoid + * the corresponding overhead. + * + * @param dev_id + * The identifier of the device. + * @param qp_id + * The index of the queue pair from which to retrieve processed packets. + * The value must be in the range [0, nb_queue_pairs - 1] previously supplied to + * rte_ml_dev_configure(). + * @param ops + * The address of an array of pointers to *rte_ml_op* structures that must be large enough to + * store *nb_ops* pointers in it. + * @param nb_ops + * The maximum number of inferences to dequeue. + * + * @return + * The number of operations actually dequeued, which is the number of pointers + * to *rte_ml_op* structures effectively supplied to the *ops* array. + */ +__rte_experimental +uint16_t +rte_ml_dequeue_burst(int16_t dev_id, uint16_t qp_id, struct rte_ml_op **ops, uint16_t nb_ops); + +/** + * Verbose error structure definition. + */ +struct rte_ml_op_error { + char message[RTE_ML_STR_MAX]; /**< Human-readable error message. */ + uint64_t errcode; /**< Vendor specific error code. */ +}; + +/** + * Get PMD specific error information for an ML op. + * + * When an ML operation completed with RTE_ML_OP_STATUS_ERROR as status, + * This API allows to get PMD specific error details. + * + * @param[in] dev_id + * Device identifier + * @param[in] op + * Handle of ML operation + * @param[in] error + * Address of structure rte_ml_op_error to be filled + * + * @return + * - Returns 0 on success + * - Returns negative value on failure + */ +__rte_experimental +int +rte_ml_op_error_get(int16_t dev_id, struct rte_ml_op *op, struct rte_ml_op_error *error); + +/* Statistics operations */ + +/** Device statistics. */ +struct rte_ml_dev_stats { + uint64_t enqueued_count; + /**< Count of all operations enqueued */ + uint64_t dequeued_count; + /**< Count of all operations dequeued */ + uint64_t enqueue_err_count; + /**< Total error count on operations enqueued */ + uint64_t dequeue_err_count; + /**< Total error count on operations dequeued */ +}; + +/** + * Retrieve the general I/O statistics of a device. + * + * @param dev_id + * The identifier of the device. + * @param stats + * Pointer to structure to where statistics will be copied. + * On error, this location may or may not have been modified. + * @return + * - 0 on success + * - -EINVAL: If invalid parameter pointer is provided. + */ +__rte_experimental +int +rte_ml_dev_stats_get(int16_t dev_id, struct rte_ml_dev_stats *stats); + +/** + * Reset the statistics of a device. + * + * @param dev_id + * The identifier of the device. + */ +__rte_experimental +void +rte_ml_dev_stats_reset(int16_t dev_id); + +/** + * A name-key lookup element for extended statistics. + * + * This structure is used to map between names and ID numbers for extended ML device statistics. + */ +struct rte_ml_dev_xstats_map { + uint16_t id; + /**< xstat identifier */ + char name[RTE_ML_STR_MAX]; + /**< xstat name */ +}; + +/** + * Retrieve names of extended statistics of an ML device. + * + * @param dev_id + * The identifier of the device. + * @param[out] xstats_map + * Block of memory to insert id and names into. Must be at least size in capacity. + * If set to NULL, function returns required capacity. + * @param size + * Capacity of xstats_map (number of name-id maps). + * + * @return + * - Positive value on success: + * - The return value is the number of entries filled in the stats map. + * - If xstats_map set to NULL then required capacity for xstats_map. + * - Negative value on error: + * - -ENODEV: for invalid *dev_id*. + * - -ENOTSUP: if the device doesn't support this function. + */ +__rte_experimental +int +rte_ml_dev_xstats_names_get(int16_t dev_id, struct rte_ml_dev_xstats_map *xstats_map, + uint32_t size); + +/** + * Retrieve the value of a single stat by requesting it by name. + * + * @param dev_id + * The identifier of the device. + * @param name + * The stat name to retrieve. + * @param stat_id + * If non-NULL, the numerical id of the stat will be returned, so that further requests for + * the stat can be got using rte_ml_dev_xstats_get, which will be faster as it doesn't need to + * scan a list of names for the stat. + * @param[out] value + * Must be non-NULL, retrieved xstat value will be stored in this address. + * + * @return + * - 0: Successfully retrieved xstat value. + * - -EINVAL: invalid parameters. + * - -ENOTSUP: if not supported. + */ +__rte_experimental +int +rte_ml_dev_xstats_by_name_get(int16_t dev_id, const char *name, uint16_t *stat_id, uint64_t *value); + +/** + * Retrieve extended statistics of an ML device. + * + * @param dev_id + * The identifier of the device. + * @param stat_ids + * The id numbers of the stats to get. The ids can be fetched from the stat position in the + * stat list from rte_ml_dev_xstats_names_get(), or by using rte_ml_dev_xstats_by_name_get(). + * @param values + * The values for each stats request by ID. + * @param nb_ids + * The number of stats requested. + * @return + * - Positive value: number of stat entries filled into the values array + * - Negative value on error: + * - -ENODEV: for invalid *dev_id*. + * - -ENOTSUP: if the device doesn't support this function. + */ +__rte_experimental +int +rte_ml_dev_xstats_get(int16_t dev_id, const uint16_t *stat_ids, uint64_t *values, uint16_t nb_ids); + +/** + * Reset the values of the xstats of the selected component in the device. + * + * @param dev_id + * The identifier of the device. + * @param stat_ids + * Selects specific statistics to be reset. When NULL, all statistics will be reset. + * If non-NULL, must point to array of at least *nb_ids* size. + * @param nb_ids + * The number of ids available from the *ids* array. Ignored when ids is NULL. + * @return + * - 0: Successfully reset the statistics to zero. + * - -EINVAL: invalid parameters. + * - -ENOTSUP: if not supported. + */ +__rte_experimental +int +rte_ml_dev_xstats_reset(int16_t dev_id, const uint16_t *stat_ids, uint16_t nb_ids); + +/* Utility operations */ + +/** + * Dump internal information about *dev_id* to the FILE* provided in *fd*. + * + * @param dev_id + * The identifier of the device. + * @param fd + * A pointer to a file for output. + * @return + * - 0: on success. + * - <0: on failure. + */ +__rte_experimental +int +rte_ml_dev_dump(int16_t dev_id, FILE *fd); + +/** + * Trigger the ML device self test. + * + * @param dev_id + * The identifier of the device. + * @return + * - 0: Selftest successful. + * - -ENOTSUP: if the device doesn't support selftest. + * - other values < 0 on failure. + */ +__rte_experimental +int +rte_ml_dev_selftest(int16_t dev_id); + +/* Model operations */ + +/** ML model load parameters + * + * Parameters required to load an ML model. + */ +struct rte_ml_model_params { + void *addr; + /**< Address of model buffer */ + size_t size; + /**< Size of model buffer */ +}; + +/** + * Load an ML model to the device. + * + * Load an ML model to the device with parameters requested in the structure rte_ml_model_params. + * + * @param[in] dev_id + * The identifier of the device. + * @param[in] params + * Parameters for the model to be loaded. + * @param[out] model_id + * Identifier of the model loaded. + * + * @return + * - 0: Success, Model loaded. + * - < 0: Failure, Error code of the model load driver function. + */ +__rte_experimental +int +rte_ml_model_load(int16_t dev_id, struct rte_ml_model_params *params, uint16_t *model_id); + +/** + * Unload an ML model from the device. + * + * @param[in] dev_id + * The identifier of the device. + * @param[in] model_id + * Identifier of the model to be unloaded. + * + * @return + * - 0: Success, Model unloaded. + * - < 0: Failure, Error code of the model unload driver function. + */ +__rte_experimental +int +rte_ml_model_unload(int16_t dev_id, uint16_t model_id); + +/** + * Start an ML model for the given device ID. + * + * Start an ML model to accept inference requests. + * + * @param[in] dev_id + * The identifier of the device. + * @param[in] model_id + * Identifier of the model to be started. + * + * @return + * - 0: Success, Model loaded. + * - < 0: Failure, Error code of the model start driver function. + */ +__rte_experimental +int +rte_ml_model_start(int16_t dev_id, uint16_t model_id); + +/** + * Stop an ML model for the given device ID. + * + * Model stop would disable the ML model to be used for inference jobs. + * All inference jobs must have been completed before model stop is attempted. + + * @param[in] dev_id + * The identifier of the device. + * @param[in] model_id + * Identifier of the model to be stopped. + * + * @return + * - 0: Success, Model unloaded. + * - < 0: Failure, Error code of the model stop driver function. + */ +__rte_experimental +int +rte_ml_model_stop(int16_t dev_id, uint16_t model_id); + +/** + * Input and output data types. ML models can operate on reduced precision + * datatypes to achieve better power efficiency, lower network latency and lower memory footprint. + * This enum is used to represent the lower precision integer and floating point types used + * by ML models. + */ +enum rte_ml_io_type { + RTE_ML_IO_TYPE_UNKNOWN = 0, + /**< Invalid or unknown type */ + RTE_ML_IO_TYPE_INT8, + /**< 8-bit integer */ + RTE_ML_IO_TYPE_UINT8, + /**< 8-bit unsigned integer */ + RTE_ML_IO_TYPE_INT16, + /**< 16-bit integer */ + RTE_ML_IO_TYPE_UINT16, + /**< 16-bit unsigned integer */ + RTE_ML_IO_TYPE_INT32, + /**< 32-bit integer */ + RTE_ML_IO_TYPE_UINT32, + /**< 32-bit unsigned integer */ + RTE_ML_IO_TYPE_FP8, + /**< 8-bit floating point number */ + RTE_ML_IO_TYPE_FP16, + /**< IEEE 754 16-bit floating point number */ + RTE_ML_IO_TYPE_FP32, + /**< IEEE 754 32-bit floating point number */ + RTE_ML_IO_TYPE_BFLOAT16 + /**< 16-bit brain floating point number. */ +}; + +/** + * Input and output format. This is used to represent the encoding type of multi-dimensional + * used by ML models. + */ +enum rte_ml_io_format { + RTE_ML_IO_FORMAT_NCHW = 1, + /**< Batch size (N) x channels (C) x height (H) x width (W) */ + RTE_ML_IO_FORMAT_NHWC, + /**< Batch size (N) x height (H) x width (W) x channels (C) */ + RTE_ML_IO_FORMAT_CHWN, + /**< Channels (C) x height (H) x width (W) x batch size (N) */ + RTE_ML_IO_FORMAT_3D, + /**< Format to represent a 3 dimensional data */ + RTE_ML_IO_FORMAT_2D, + /**< Format to represent matrix data */ + RTE_ML_IO_FORMAT_1D, + /**< Format to represent vector data */ + RTE_ML_IO_FORMAT_SCALAR, + /**< Format to represent scalar data */ +}; + +/** + * Input and output shape. This structure represents the encoding format and dimensions + * of the tensor or vector. + * + * The data can be a 4D / 3D tensor, matrix, vector or a scalar. Number of dimensions used + * for the data would depend on the format. Unused dimensions to be set to 1. + */ +struct rte_ml_io_shape { + enum rte_ml_io_format format; + /**< Format of the data */ + uint32_t w; + /**< First dimension */ + uint32_t x; + /**< Second dimension */ + uint32_t y; + /**< Third dimension */ + uint32_t z; + /**< Fourth dimension */ +}; + +/** Input and output data information structure + * + * Specifies the type and shape of input and output data. + */ +struct rte_ml_io_info { + char name[RTE_ML_STR_MAX]; + /**< Name of data */ + struct rte_ml_io_shape shape; + /**< Shape of data */ + enum rte_ml_io_type qtype; + /**< Type of quantized data */ + enum rte_ml_io_type dtype; + /**< Type of de-quantized data */ +}; + +/** Model information structure */ +struct rte_ml_model_info { + char name[RTE_ML_STR_MAX]; + /**< Model name. */ + char version[RTE_ML_STR_MAX]; + /**< Model version */ + uint16_t model_id; + /**< Model ID */ + uint16_t device_id; + /**< Device ID */ + uint16_t batch_size; + /**< Maximum number of batches that the model can process simultaneously */ + uint32_t nb_inputs; + /**< Number of inputs */ + const struct rte_ml_io_info *input_info; + /**< Input info array. Array size is equal to nb_inputs */ + uint32_t nb_outputs; + /**< Number of outputs */ + const struct rte_ml_io_info *output_info; + /**< Output info array. Array size is equal to nb_output */ + uint64_t wb_size; + /**< Size of model weights and bias */ +}; + +/** + * Get ML model information. + * + * @param[in] dev_id + * The identifier of the device. + * @param[in] model_id + * Identifier for the model created + * @param[out] model_info + * Pointer to a model info structure + * + * @return + * - Returns 0 on success + * - Returns negative value on failure + */ +__rte_experimental +int +rte_ml_model_info_get(int16_t dev_id, uint16_t model_id, struct rte_ml_model_info *model_info); + +/** + * Update the model parameters without unloading model. + * + * Update model parameters such as weights and bias without unloading the model. + * rte_ml_model_stop() must be called before invoking this API. + * + * @param[in] dev_id + * The identifier of the device. + * @param[in] model_id + * Identifier for the model created + * @param[in] buffer + * Pointer to the model weights and bias buffer. + * Size of the buffer is equal to wb_size returned in *rte_ml_model_info*. + * + * @return + * - Returns 0 on success + * - Returns negative value on failure + */ +__rte_experimental +int +rte_ml_model_params_update(int16_t dev_id, uint16_t model_id, void *buffer); + +/* IO operations */ + +/** + * Get size of quantized and dequantized input buffers. + * + * Calculate the size of buffers required for quantized and dequantized input data. + * This API would return the buffer sizes for the number of batches provided and would + * consider the alignment requirements as per the PMD. Input sizes computed by this API can + * be used by the application to allocate buffers. + * + * @param[in] dev_id + * The identifier of the device. + * @param[in] model_id + * Identifier for the model created + * @param[in] nb_batches + * Number of batches of input to be processed in a single inference job + * @param[out] input_qsize + * Quantized input size pointer. + * NULL value is allowed, in which case input_qsize is not calculated by the driver. + * @param[out] input_dsize + * Dequantized input size pointer. + * NULL value is allowed, in which case input_dsize is not calculated by the driver. + * + * @return + * - Returns 0 on success + * - Returns negative value on failure + */ +__rte_experimental +int +rte_ml_io_input_size_get(int16_t dev_id, uint16_t model_id, uint32_t nb_batches, + uint64_t *input_qsize, uint64_t *input_dsize); + +/** + * Get size of quantized and dequantized output buffers. + * + * Calculate the size of buffers required for quantized and dequantized output data. + * This API would return the buffer sizes for the number of batches provided and would consider + * the alignment requirements as per the PMD. Output sizes computed by this API can be used by the + * application to allocate buffers. + * + * @param[in] dev_id + * The identifier of the device. + * @param[in] model_id + * Identifier for the model created + * @param[in] nb_batches + * Number of batches of input to be processed in a single inference job + * @param[out] output_qsize + * Quantized output size pointer. + * NULL value is allowed, in which case output_qsize is not calculated by the driver. + * @param[out] output_dsize + * Dequantized output size pointer. + * NULL value is allowed, in which case output_dsize is not calculated by the driver. + * + * @return + * - Returns 0 on success + * - Returns negative value on failure + */ +__rte_experimental +int +rte_ml_io_output_size_get(int16_t dev_id, uint16_t model_id, uint32_t nb_batches, + uint64_t *output_qsize, uint64_t *output_dsize); + +/** + * Quantize input data. + * + * Quantization converts data from a higher precision types to a lower precision types to improve + * the throughput and efficiency of the model execution with minimal loss of accuracy. + * Types of dequantized data and quantized data are specified by the model. + * + * @param[in] dev_id + * The identifier of the device. + * @param[in] model_id + * Identifier for the model + * @param[in] nb_batches + * Number of batches in the dequantized input buffer + * @param[in] dbuffer + * Address of dequantized input data + * @param[in] qbuffer + * Address of quantized input data + * + * @return + * - Returns 0 on success + * - Returns negative value on failure + */ +__rte_experimental +int +rte_ml_io_quantize(int16_t dev_id, uint16_t model_id, uint16_t nb_batches, void *dbuffer, + void *qbuffer); + +/** + * Dequantize output data. + * + * Dequantization converts data from a lower precision type to a higher precision type. + * Types of quantized data and dequantized are specified by the model. + * + * @param[in] dev_id + * The identifier of the device. + * @param[in] model_id + * Identifier for the model + * @param[in] nb_batches + * Number of batches in the dequantized output buffer + * @param[in] qbuffer + * Address of quantized output data + * @param[in] dbuffer + * Address of dequantized output data + * + * @return + * - Returns 0 on success + * - Returns negative value on failure + */ +__rte_experimental +int +rte_ml_io_dequantize(int16_t dev_id, uint16_t model_id, uint16_t nb_batches, void *qbuffer, + void *dbuffer); + +/* ML op pool operations */ + +/** + * Create an ML operation pool + * + * @param name + * ML operations pool name + * @param nb_elts + * Number of elements in pool + * @param cache_size + * Number of elements to cache on lcore, see + * *rte_mempool_create* for further details about cache size + * @param user_size + * Size of private data to allocate for user with each operation + * @param socket_id + * Socket to identifier allocate memory on + * @return + * - On success pointer to mempool + * - On failure NULL + */ +__rte_experimental +struct rte_mempool * +rte_ml_op_pool_create(const char *name, unsigned int nb_elts, unsigned int cache_size, + uint16_t user_size, int socket_id); + +/** + * Free an ML operation pool + * + * @param mempool + * A pointer to the mempool structure. + * If NULL then, the function does nothing. + */ +__rte_experimental +void +rte_ml_op_pool_free(struct rte_mempool *mempool); + +#ifdef __cplusplus +} +#endif + +#endif /* RTE_MLDEV_H */ diff --git a/lib/mldev/version.map b/lib/mldev/version.map new file mode 100644 index 0000000000..3793380442 --- /dev/null +++ b/lib/mldev/version.map @@ -0,0 +1,7 @@ +EXPERIMENTAL { + global: + + rte_ml_dev_logtype; + + local: *; +}; From patchwork Tue Feb 7 15:13:06 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 123258 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 1FB0241C30; Tue, 7 Feb 2023 16:13:50 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 52D5A42C24; Tue, 7 Feb 2023 16:13:42 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id D12EE427F5 for ; Tue, 7 Feb 2023 16:13:40 +0100 (CET) Received: from pps.filterd (m0045849.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 317ETPBB023009; Tue, 7 Feb 2023 07:13:39 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=4SZdLgxCy2NOmI1tNlGTUjMlEzlUgCv1zBL7+1IMLlA=; b=knxF+wEYqCIK+8B+h41v2rBFyVqHNcJZwZ8rqYZ6hGNvDJBnRS9t8uZMJyNv9TGS5bpo JePCi9t0ojsycW8nfRj2Aj3YIhAPR9SAfeElr432XV0KD24C4Az33jLG0an3MzhlCi+G rzzQxeHvRwfwYSZE5BMs/+PjVZh0N7wWI4yjLIqt3kI6YUbyiT80jk6aX1nhAwJcWtLv 2w0geQJ5FDrbE9i2uf+3oMqvm3XKcQ1eYGli/wZ+ZsY1E/0iJ5utuKNWSiy0xGYMGCSr W4HqbF+NuFatU0v9p8jdPelEax/tSY1qtWdizGbmR1rLQitHUg25XNNQ/DRNFGkZBpUE kg== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3nkdyrsk1b-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Tue, 07 Feb 2023 07:13:39 -0800 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.42; Tue, 7 Feb 2023 07:13:37 -0800 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.42 via Frontend Transport; Tue, 7 Feb 2023 07:13:37 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id E827B3F7083; Tue, 7 Feb 2023 07:13:34 -0800 (PST) From: To: , Srikanth Yalavarthi , "Anatoly Burakov" CC: , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v3 02/12] mldev: support PMD functions for ML device Date: Tue, 7 Feb 2023 20:43:06 +0530 Message-ID: <20230207151316.835441-3-jerinj@marvell.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230207151316.835441-1-jerinj@marvell.com> References: <20230206202453.336280-1-jerinj@marvell.com> <20230207151316.835441-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: qrfwn85w6idHQpm_yBa9SPyf6RDjJkhi X-Proofpoint-GUID: qrfwn85w6idHQpm_yBa9SPyf6RDjJkhi X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-07_07,2023-02-06_03,2022-06-22_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Srikanth Yalavarthi Added PMD functions to handle ML devices. The rte_mldev_pmd.* files are for drivers only and should be private to DPDK, and are not installed for application use. Added implementation for rte_ml_dev_init. Signed-off-by: Srikanth Yalavarthi Signed-off-by: Jerin Jacob --- lib/mldev/meson.build | 9 ++ lib/mldev/rte_mldev.c | 172 +++++++++++++++++++++++++++++++++++++ lib/mldev/rte_mldev_core.h | 108 +++++++++++++++++++++++ lib/mldev/rte_mldev_pmd.c | 62 +++++++++++++ lib/mldev/rte_mldev_pmd.h | 149 ++++++++++++++++++++++++++++++++ lib/mldev/version.map | 12 +++ 6 files changed, 512 insertions(+) create mode 100644 lib/mldev/rte_mldev_core.h create mode 100644 lib/mldev/rte_mldev_pmd.c create mode 100644 lib/mldev/rte_mldev_pmd.h diff --git a/lib/mldev/meson.build b/lib/mldev/meson.build index e378cfca30..5c99532c1a 100644 --- a/lib/mldev/meson.build +++ b/lib/mldev/meson.build @@ -2,6 +2,7 @@ # Copyright (c) 2022 Marvell. sources = files( + 'rte_mldev_pmd.c', 'rte_mldev.c', ) @@ -9,6 +10,14 @@ headers = files( 'rte_mldev.h', ) +indirect_headers += files( + 'rte_mldev_core.h', +) + +driver_sdk_headers += files( + 'rte_mldev_pmd.h', +) + deps += ['mempool'] if get_option('buildtype').contains('debug') diff --git a/lib/mldev/rte_mldev.c b/lib/mldev/rte_mldev.c index 70aad4c44b..833afcbf87 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -2,7 +2,179 @@ * Copyright (c) 2022 Marvell. */ +#include #include #include +#include + +#include + +static struct rte_ml_dev_global ml_dev_globals = { + .devs = NULL, .data = NULL, .nb_devs = 0, .max_devs = RTE_MLDEV_DEFAULT_MAX}; + +struct rte_ml_dev * +rte_ml_dev_pmd_get_dev(int16_t dev_id) +{ + return &ml_dev_globals.devs[dev_id]; +} + +struct rte_ml_dev * +rte_ml_dev_pmd_get_named_dev(const char *name) +{ + struct rte_ml_dev *dev; + int16_t dev_id; + + if (name == NULL) + return NULL; + + for (dev_id = 0; dev_id < ml_dev_globals.max_devs; dev_id++) { + dev = rte_ml_dev_pmd_get_dev(dev_id); + if ((dev->attached == ML_DEV_ATTACHED) && (strcmp(dev->data->name, name) == 0)) + return dev; + } + + return NULL; +} + +struct rte_ml_dev * +rte_ml_dev_pmd_allocate(const char *name, uint8_t socket_id) +{ + char mz_name[RTE_MEMZONE_NAMESIZE]; + const struct rte_memzone *mz; + struct rte_ml_dev *dev; + int16_t dev_id; + + /* implicit initialization of library before adding first device */ + if (ml_dev_globals.devs == NULL) { + if (rte_ml_dev_init(RTE_MLDEV_DEFAULT_MAX) != 0) + return NULL; + } + + if (rte_ml_dev_pmd_get_named_dev(name) != NULL) { + RTE_MLDEV_LOG(ERR, "ML device with name %s already allocated!", name); + return NULL; + } + + /* Get a free device ID */ + for (dev_id = 0; dev_id < ml_dev_globals.max_devs; dev_id++) { + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (dev->attached == ML_DEV_DETACHED) + break; + } + + if (dev_id == ml_dev_globals.max_devs) { + RTE_MLDEV_LOG(ERR, "Reached maximum number of ML devices"); + return NULL; + } + + if (dev->data == NULL) { + /* Reserve memzone name */ + sprintf(mz_name, "rte_ml_dev_data_%d", dev_id); + if (rte_eal_process_type() == RTE_PROC_PRIMARY) { + mz = rte_memzone_reserve(mz_name, sizeof(struct rte_ml_dev_data), socket_id, + 0); + RTE_MLDEV_LOG(DEBUG, "PRIMARY: reserved memzone for %s (%p)", mz_name, mz); + } else { + mz = rte_memzone_lookup(mz_name); + RTE_MLDEV_LOG(DEBUG, "SECONDARY: looked up memzone for %s (%p)", mz_name, + mz); + } + + if (mz == NULL) + return NULL; + + ml_dev_globals.data[dev_id] = mz->addr; + if (rte_eal_process_type() == RTE_PROC_PRIMARY) + memset(ml_dev_globals.data[dev_id], 0, sizeof(struct rte_ml_dev_data)); + + dev->data = ml_dev_globals.data[dev_id]; + if (rte_eal_process_type() == RTE_PROC_PRIMARY) { + strlcpy(dev->data->name, name, RTE_ML_STR_MAX); + dev->data->dev_id = dev_id; + dev->data->socket_id = socket_id; + dev->data->dev_started = 0; + RTE_MLDEV_LOG(DEBUG, "PRIMARY: init mldev data"); + } + + RTE_MLDEV_LOG(DEBUG, "Data for %s: dev_id %d, socket %u", dev->data->name, + dev->data->dev_id, dev->data->socket_id); + + dev->attached = ML_DEV_ATTACHED; + ml_dev_globals.nb_devs++; + } + + return dev; +} + +int +rte_ml_dev_pmd_release(struct rte_ml_dev *dev) +{ + char mz_name[RTE_MEMZONE_NAMESIZE]; + const struct rte_memzone *mz; + int16_t dev_id; + int ret = 0; + + if (dev == NULL) + return -EINVAL; + + dev_id = dev->data->dev_id; + + /* Memzone lookup */ + sprintf(mz_name, "rte_ml_dev_data_%d", dev_id); + mz = rte_memzone_lookup(mz_name); + if (mz == NULL) + return -ENOMEM; + + RTE_ASSERT(ml_dev_globals.data[dev_id] == mz->addr); + ml_dev_globals.data[dev_id] = NULL; + + if (rte_eal_process_type() == RTE_PROC_PRIMARY) { + RTE_MLDEV_LOG(DEBUG, "PRIMARY: free memzone of %s (%p)", mz_name, mz); + ret = rte_memzone_free(mz); + } else { + RTE_MLDEV_LOG(DEBUG, "SECONDARY: don't free memzone of %s (%p)", mz_name, mz); + } + + dev->attached = ML_DEV_DETACHED; + ml_dev_globals.nb_devs--; + + return ret; +} + +int +rte_ml_dev_init(size_t dev_max) +{ + if (dev_max == 0 || dev_max > INT16_MAX) { + RTE_MLDEV_LOG(ERR, "Invalid dev_max = %zu (> %d)\n", dev_max, INT16_MAX); + rte_errno = EINVAL; + return -rte_errno; + } + + /* No lock, it must be called before or during first probing. */ + if (ml_dev_globals.devs != NULL) { + RTE_MLDEV_LOG(ERR, "Device array already initialized"); + rte_errno = EBUSY; + return -rte_errno; + } + + ml_dev_globals.devs = calloc(dev_max, sizeof(struct rte_ml_dev)); + if (ml_dev_globals.devs == NULL) { + RTE_MLDEV_LOG(ERR, "Cannot initialize MLDEV library"); + rte_errno = ENOMEM; + return -rte_errno; + } + + ml_dev_globals.data = calloc(dev_max, sizeof(struct rte_ml_dev_data *)); + if (ml_dev_globals.data == NULL) { + RTE_MLDEV_LOG(ERR, "Cannot initialize MLDEV library"); + rte_errno = ENOMEM; + return -rte_errno; + } + + ml_dev_globals.max_devs = dev_max; + ml_dev_globals.devs = ml_dev_globals.devs; + + return 0; +} RTE_LOG_REGISTER_DEFAULT(rte_ml_dev_logtype, INFO); diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h new file mode 100644 index 0000000000..1564d0fa4d --- /dev/null +++ b/lib/mldev/rte_mldev_core.h @@ -0,0 +1,108 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2022 Marvell. + */ + +#ifndef _RTE_MLDEV_INTERNAL_H_ +#define _RTE_MLDEV_INTERNAL_H_ + +/** + * @file + * + * MLDEV internal header + * + * This file contains MLDEV private data structures and macros. + * + * @note + * These APIs are for MLDEV PMDs and library only. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#include +#include +#include +#include + +/* Device state */ +#define ML_DEV_DETACHED (0) +#define ML_DEV_ATTACHED (1) + +/** + * @internal + * + * The data part, with no function pointers, associated with each device. This structure is safe to + * place in shared memory to be common among different processes in a multi-process configuration. + */ +struct rte_ml_dev_data { + /** Device ID for this instance. */ + int16_t dev_id; + + /** Socket ID where memory is allocated. */ + int16_t socket_id; + + /** Device state: STOPPED(0) / STARTED(1) */ + __extension__ uint8_t dev_started : 1; + + /** Number of device queue pairs. */ + uint16_t nb_queue_pairs; + + /** Number of ML models. */ + uint16_t nb_models; + + /** Array of pointers to queue pairs. */ + void **queue_pairs; + + /** Array of pointers to ML models. */ + void **models; + + /** PMD-specific private data. */ + void *dev_private; + + /** Unique identifier name. */ + char name[RTE_ML_STR_MAX]; +}; + +/** + * @internal + * + * The data structure associated with each ML device. + */ +struct rte_ml_dev { + /** Pointer to device data. */ + struct rte_ml_dev_data *data; + + /** Backing RTE device. */ + struct rte_device *device; + + /** Flag indicating the device is attached. */ + __extension__ uint8_t attached : 1; +} __rte_cache_aligned; + +/** + * @internal + * + * Global structure used for maintaining state of allocated ML devices. + */ +struct rte_ml_dev_global { + /** Device information array. */ + struct rte_ml_dev *devs; + + /** Device private data array. */ + struct rte_ml_dev_data **data; + + /** Number of devices found. */ + uint8_t nb_devs; + + /** Maximum number of devices. */ + uint8_t max_devs; +}; + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_MLDEV_INTERNAL_H_ */ diff --git a/lib/mldev/rte_mldev_pmd.c b/lib/mldev/rte_mldev_pmd.c new file mode 100644 index 0000000000..3169e5d4fa --- /dev/null +++ b/lib/mldev/rte_mldev_pmd.c @@ -0,0 +1,62 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2022 Marvell. + */ + +#include +#include +#include + +#include "rte_mldev_pmd.h" + +struct rte_ml_dev * +rte_ml_dev_pmd_create(const char *name, struct rte_device *device, + struct rte_ml_dev_pmd_init_params *params) +{ + struct rte_ml_dev *dev; + + RTE_MLDEV_LOG(INFO, "ML device initialisation - name: %s, socket_id: %u", name, + params->socket_id); + + /* Allocate device structure */ + dev = rte_ml_dev_pmd_allocate(name, params->socket_id); + if (dev == NULL) { + RTE_MLDEV_LOG(ERR, "Failed to allocate ML device for %s", name); + return NULL; + } + + /* Allocate private device structure */ + if (rte_eal_process_type() == RTE_PROC_PRIMARY) { + dev->data->dev_private = + rte_zmalloc_socket("ml_dev_private", params->private_data_size, + RTE_CACHE_LINE_SIZE, params->socket_id); + + if (dev->data->dev_private == NULL) { + RTE_MLDEV_LOG(ERR, "Cannot allocate memory for mldev %s private data", + name); + rte_ml_dev_pmd_release(dev); + return NULL; + } + } + dev->device = device; + + return dev; +} + +int +rte_ml_dev_pmd_destroy(struct rte_ml_dev *dev) +{ + int ret; + + RTE_MLDEV_LOG(INFO, "Releasing ML device - name: %s", dev->device->name); + ret = rte_ml_dev_pmd_release(dev); + if (ret) + return ret; + + if (rte_eal_process_type() == RTE_PROC_PRIMARY) + rte_free(dev->data->dev_private); + + dev->data = NULL; + dev->device = NULL; + + return 0; +} diff --git a/lib/mldev/rte_mldev_pmd.h b/lib/mldev/rte_mldev_pmd.h new file mode 100644 index 0000000000..33544f1b80 --- /dev/null +++ b/lib/mldev/rte_mldev_pmd.h @@ -0,0 +1,149 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2022 Marvell. + */ + +#ifndef _RTE_MLDEV_PMD_H_ +#define _RTE_MLDEV_PMD_H_ + +/** + * @file + * + * RTE MLDEV PMD APIs + * + * ML Device PMD interface + * + * @note + * These APIs are for MLDEV PMDs only and user applications should not call them directly. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#include +#include +#include +#include + +/** + * @internal + * + * Initialisation parameters for ML devices. + */ +struct rte_ml_dev_pmd_init_params { + /** Socket to use for memory allocation. */ + uint8_t socket_id; + + /** Size of device private data. */ + uint64_t private_data_size; +}; + +/** + * @internal + * + * Get the ML device pointer for the device. Assumes a valid device index. + * + * @param dev_id + * Device ID value to select the device structure. + * + * @return + * The rte_ml_dev pointer for the given device ID. + */ +__rte_internal +struct rte_ml_dev * +rte_ml_dev_pmd_get_dev(int16_t dev_id); + +/** + * @internal + * + * Get the rte_ml_dev structure device pointer for the named device. + * + * @param name + * Device name to select the device structure. + * + * @return + * The rte_ml_dev pointer for the given device ID. + */ +__rte_internal +struct rte_ml_dev * +rte_ml_dev_pmd_get_named_dev(const char *name); + +/** + * @internal + * + * Allocates a new mldev slot for an ML device and returns the pointer to that slot for use. + * Function for internal use by dummy drivers. + * + * @param name + * Unique identifier name for each device. + * @param socket_id + * Socket to allocate resources. + * + * @return + * Slot in the rte_ml_dev_devices array for a new device. + */ +__rte_internal +struct rte_ml_dev * +rte_ml_dev_pmd_allocate(const char *name, uint8_t socket_id); + +/** + * @internal + * + * Release the specified mldev device. + * + * @param dev + * ML device. + * @return + * - 0 on success. + * - < 0, error code on failure. + */ +__rte_internal +int +rte_ml_dev_pmd_release(struct rte_ml_dev *dev); + +/** + * @internal + * + * PMD assist function to provide boiler plate code for ML driver to create and allocate resources + * for a new ML PMD device instance. + * + * @param name + * ML device name. + * @param device + * Base device handle. + * @param params + * PMD initialisation parameters. + * + * @return + * - ML device instance on success. + * - NULL on failure. + */ +__rte_internal +struct rte_ml_dev * +rte_ml_dev_pmd_create(const char *name, struct rte_device *device, + struct rte_ml_dev_pmd_init_params *params); + +/** + * @internal + * + * PMD assist function to provide boiler plate code for ML driver to destroy and free resources + * associated with a ML PMD device instance. + * + * @param mldev + * ML device instance. + * + * @return + * - 0 on success. + * - < 0, error code on failure. + */ +__rte_internal +int +rte_ml_dev_pmd_destroy(struct rte_ml_dev *mldev); + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_MLDEV_PMD_H_ */ diff --git a/lib/mldev/version.map b/lib/mldev/version.map index 3793380442..d6bf7c8ebb 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -1,7 +1,19 @@ EXPERIMENTAL { global: + rte_ml_dev_init; rte_ml_dev_logtype; local: *; }; + +INTERNAL { + global: + + rte_ml_dev_pmd_allocate; + rte_ml_dev_pmd_create; + rte_ml_dev_pmd_destroy; + rte_ml_dev_pmd_get_dev; + rte_ml_dev_pmd_get_named_dev; + rte_ml_dev_pmd_release; +}; From patchwork Tue Feb 7 15:13:07 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 123259 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id BA12041C30; Tue, 7 Feb 2023 16:13:57 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 6077D427F5; Tue, 7 Feb 2023 16:13:45 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id 26767427F5 for ; Tue, 7 Feb 2023 16:13:44 +0100 (CET) Received: from pps.filterd (m0045849.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 317EdPWX011264; Tue, 7 Feb 2023 07:13:43 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=+qrFVdZdihsqAtrh8xmMKPCojouHLHETmWCqZPOOcZo=; b=chZG4tuf9VzwxFggH/4iFa7BAufxPH4BLCxHi9+aIjEfA6oE/dcsuRekLjd/gmumP+Mx R8SejcTbNJJRT0ny4ThypBc+Zb4uTF3fpJDSPps9Hp6BWsExdUDuOnGTTsWLTON4Jk3I rPPAvcqpdfYJzjeQu5gvvSeniiw7QeEhuWAcB2JOgHtjr0sk/jnzeXBj1XUPrXGzFhZu rGX3VEwsER38oq01h19hTPo0cgwJSqlH1rpkdd9n0wO2QLi3uWJDNaJzVVS/IyP3qUY+ Kt4kay7OkUwHe/wwr2wk7MHjUkDdcTEk2VFFLcxTcyNY05BdcO6VkMPUxZnVb16AgMvK 6w== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3nkdyrsk1v-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Tue, 07 Feb 2023 07:13:43 -0800 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.42; Tue, 7 Feb 2023 07:13:41 -0800 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.42 via Frontend Transport; Tue, 7 Feb 2023 07:13:41 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id E9CEF3F7083; Tue, 7 Feb 2023 07:13:38 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v3 03/12] mldev: support ML device handling functions Date: Tue, 7 Feb 2023 20:43:07 +0530 Message-ID: <20230207151316.835441-4-jerinj@marvell.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230207151316.835441-1-jerinj@marvell.com> References: <20230206202453.336280-1-jerinj@marvell.com> <20230207151316.835441-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: htZCRTZOl1Bhdvl7ZcU8BpnlSnHqlJnx X-Proofpoint-GUID: htZCRTZOl1Bhdvl7ZcU8BpnlSnHqlJnx X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-07_07,2023-02-06_03,2022-06-22_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Srikanth Yalavarthi Added ML device handling APIs. These APIs are used to get device information, configure, start, stop and close ML devices. Added function prototypes to PMD layer which are used by the ML driver implementations in the poll mode driver. Signed-off-by: Srikanth Yalavarthi Signed-off-by: Jerin Jacob --- lib/mldev/rte_mldev.c | 175 +++++++++++++++++++++++++++++++++++++ lib/mldev/rte_mldev_core.h | 107 +++++++++++++++++++++++ lib/mldev/version.map | 8 ++ 3 files changed, 290 insertions(+) diff --git a/lib/mldev/rte_mldev.c b/lib/mldev/rte_mldev.c index 833afcbf87..961e12d150 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -177,4 +177,179 @@ rte_ml_dev_init(size_t dev_max) return 0; } +uint16_t +rte_ml_dev_count(void) +{ + return ml_dev_globals.nb_devs; +} + +int +rte_ml_dev_is_valid_dev(int16_t dev_id) +{ + struct rte_ml_dev *dev = NULL; + + if (dev_id >= ml_dev_globals.max_devs || ml_dev_globals.devs[dev_id].data == NULL) + return 0; + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (dev->attached != ML_DEV_ATTACHED) + return 0; + else + return 1; +} + +int +rte_ml_dev_socket_id(int16_t dev_id) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + + return dev->data->socket_id; +} + +int +rte_ml_dev_info_get(int16_t dev_id, struct rte_ml_dev_info *dev_info) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->dev_info_get == NULL) + return -ENOTSUP; + + if (dev_info == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, dev_info cannot be NULL\n", dev_id); + return -EINVAL; + } + memset(dev_info, 0, sizeof(struct rte_ml_dev_info)); + + return (*dev->dev_ops->dev_info_get)(dev, dev_info); +} + +int +rte_ml_dev_configure(int16_t dev_id, const struct rte_ml_dev_config *config) +{ + struct rte_ml_dev_info dev_info; + struct rte_ml_dev *dev; + int ret; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->dev_configure == NULL) + return -ENOTSUP; + + if (dev->data->dev_started) { + RTE_MLDEV_LOG(ERR, "Device %d must be stopped to allow configuration", dev_id); + return -EBUSY; + } + + if (config == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, config cannot be NULL\n", dev_id); + return -EINVAL; + } + + ret = rte_ml_dev_info_get(dev_id, &dev_info); + if (ret < 0) + return ret; + + if (config->nb_queue_pairs > dev_info.max_queue_pairs) { + RTE_MLDEV_LOG(ERR, "Device %d num of queues %u > %u\n", dev_id, + config->nb_queue_pairs, dev_info.max_queue_pairs); + return -EINVAL; + } + + return (*dev->dev_ops->dev_configure)(dev, config); +} + +int +rte_ml_dev_close(int16_t dev_id) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->dev_close == NULL) + return -ENOTSUP; + + /* Device must be stopped before it can be closed */ + if (dev->data->dev_started == 1) { + RTE_MLDEV_LOG(ERR, "Device %d must be stopped before closing", dev_id); + return -EBUSY; + } + + return (*dev->dev_ops->dev_close)(dev); +} + +int +rte_ml_dev_start(int16_t dev_id) +{ + struct rte_ml_dev *dev; + int ret; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->dev_start == NULL) + return -ENOTSUP; + + if (dev->data->dev_started != 0) { + RTE_MLDEV_LOG(ERR, "Device %d is already started", dev_id); + return -EBUSY; + } + + ret = (*dev->dev_ops->dev_start)(dev); + if (ret == 0) + dev->data->dev_started = 1; + + return ret; +} + +int +rte_ml_dev_stop(int16_t dev_id) +{ + struct rte_ml_dev *dev; + int ret; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->dev_stop == NULL) + return -ENOTSUP; + + if (dev->data->dev_started == 0) { + RTE_MLDEV_LOG(ERR, "Device %d is not started", dev_id); + return -EBUSY; + } + + ret = (*dev->dev_ops->dev_stop)(dev); + if (ret == 0) + dev->data->dev_started = 0; + + return ret; +} + RTE_LOG_REGISTER_DEFAULT(rte_ml_dev_logtype, INFO); diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index 1564d0fa4d..dc79c5f630 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -31,6 +31,110 @@ extern "C" { #define ML_DEV_DETACHED (0) #define ML_DEV_ATTACHED (1) +struct rte_ml_dev; + +/** + * Definitions of all functions exported by a driver through the generic structure of type + * *ml_dev_ops* supplied in the *rte_ml_dev* structure associated with a device. + */ + +/** + * @internal + * + * Function used to get device information. + * + * @param dev + * ML device pointer. + * @param dev_info + * Pointer to info structure. + * + * @return + * - 0 on success. + * - < 0, error code on failure. + */ +typedef int (*mldev_info_get_t)(struct rte_ml_dev *dev, struct rte_ml_dev_info *dev_info); + +/** + * @internal + * + * Function used to configure device. + * + * @param dev + * ML device pointer. + * @param config + * ML device configurations. + * + * @return + * - 0 on success + * - < 0, error code on failure. + */ +typedef int (*mldev_configure_t)(struct rte_ml_dev *dev, const struct rte_ml_dev_config *config); + +/** + * @internal + * + * Function used to close a configured device. + * + * @param dev + * ML device pointer. + * + * @return + * - 0 on success. + * - -EAGAIN if can't close as device is busy. + * - < 0, error code on failure, other than busy. + */ +typedef int (*mldev_close_t)(struct rte_ml_dev *dev); + +/** + * @internal + * + * Function used to start a configured device. + * + * @param dev + * ML device pointer. + * + * @return + * - 0 on success. + * - < 0, error code on failure. + */ +typedef int (*mldev_start_t)(struct rte_ml_dev *dev); + +/** + * @internal + * + * Function used to stop a configured device. + * + * @param dev + * ML device pointer. + * + * @return + * - 0 on success. + * - < 0, error code on failure. + */ +typedef int (*mldev_stop_t)(struct rte_ml_dev *dev); + +/** + * @internal + * + * ML device operations function pointer table. + */ +struct rte_ml_dev_ops { + /** Get device information. */ + mldev_info_get_t dev_info_get; + + /** Configure device. */ + mldev_configure_t dev_configure; + + /** Close device. */ + mldev_close_t dev_close; + + /** Start device. */ + mldev_start_t dev_start; + + /** Stop device. */ + mldev_stop_t dev_stop; +}; + /** * @internal * @@ -75,6 +179,9 @@ struct rte_ml_dev { /** Pointer to device data. */ struct rte_ml_dev_data *data; + /** Functions exported by PMD. */ + struct rte_ml_dev_ops *dev_ops; + /** Backing RTE device. */ struct rte_device *device; diff --git a/lib/mldev/version.map b/lib/mldev/version.map index d6bf7c8ebb..028b6a464d 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -1,8 +1,16 @@ EXPERIMENTAL { global: + rte_ml_dev_close; + rte_ml_dev_configure; + rte_ml_dev_count; + rte_ml_dev_info_get; rte_ml_dev_init; + rte_ml_dev_is_valid_dev; rte_ml_dev_logtype; + rte_ml_dev_socket_id; + rte_ml_dev_start; + rte_ml_dev_stop; local: *; }; From patchwork Tue Feb 7 15:13:08 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 123260 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 878AC41C30; Tue, 7 Feb 2023 16:14:04 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 9955242B8E; Tue, 7 Feb 2023 16:13:49 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id 0470A42D13 for ; Tue, 7 Feb 2023 16:13:47 +0100 (CET) Received: from pps.filterd (m0045849.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 317EbMa2006803; Tue, 7 Feb 2023 07:13:47 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=9mz4lbUkZi+a0N8cymXUDMnol+IVJxxQx9OVO4oZFPo=; b=GWrKtluGvx+MoIYkkPP23gB8Ygn8FCwmT45oArUMuEBw4Gz6MFA97EBRHKp8lQGcVGtu iJb9w/L6c/kOV3RsjdL4Ac53grjeZJdDVVebVvoxioKjFhevcsMpkYtj2p3j+Bd6ZzRs Lw7YUHE4IdgKyx/TLkByJ6C0k0QKVFmiXIZY4Oizwu2Zik7aCJJ+9WW931S6DNuAaMoN stFs/9DSK92YL65yaL+NvCMtd5nzaobyfrOMBpyIEJWGsxievc/p6l9QCIToXmLqestj 7Vx39xiKwzh7VXm9tM1aBHtEIN+r/1OAqVynug4/l2jOR8HgLT5zmrzYwn5Rb+IFQFDE Aw== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3nkdyrsk25-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Tue, 07 Feb 2023 07:13:47 -0800 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.42; Tue, 7 Feb 2023 07:13:45 -0800 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.42 via Frontend Transport; Tue, 7 Feb 2023 07:13:45 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id CFE2F3F7082; Tue, 7 Feb 2023 07:13:42 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v3 04/12] mldev: support ML device queue-pair setup Date: Tue, 7 Feb 2023 20:43:08 +0530 Message-ID: <20230207151316.835441-5-jerinj@marvell.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230207151316.835441-1-jerinj@marvell.com> References: <20230206202453.336280-1-jerinj@marvell.com> <20230207151316.835441-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: QfXb-2AMwP-LKXechMr2Q_1RV4V9Q_t0 X-Proofpoint-GUID: QfXb-2AMwP-LKXechMr2Q_1RV4V9Q_t0 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-07_07,2023-02-06_03,2022-06-22_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Srikanth Yalavarthi Added APIs to create a queue-pair attached to ML device. Queue pairs are created with a user specified ID. Added function prototypes to be used by ML drivers for queue pair create and destroy. Signed-off-by: Srikanth Yalavarthi Signed-off-by: Jerin Jacob --- lib/mldev/rte_mldev.c | 33 ++++++++++++++++++++++++++++ lib/mldev/rte_mldev_core.h | 44 ++++++++++++++++++++++++++++++++++++++ lib/mldev/version.map | 1 + 3 files changed, 78 insertions(+) diff --git a/lib/mldev/rte_mldev.c b/lib/mldev/rte_mldev.c index 961e12d150..928ea90ab5 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -352,4 +352,37 @@ rte_ml_dev_stop(int16_t dev_id) return ret; } +int +rte_ml_dev_queue_pair_setup(int16_t dev_id, uint16_t queue_pair_id, + const struct rte_ml_dev_qp_conf *qp_conf, int socket_id) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->dev_queue_pair_setup == NULL) + return -ENOTSUP; + + if (queue_pair_id >= dev->data->nb_queue_pairs) { + RTE_MLDEV_LOG(ERR, "Invalid queue_pair_id = %d", queue_pair_id); + return -EINVAL; + } + + if (qp_conf == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, qp_conf cannot be NULL\n", dev_id); + return -EINVAL; + } + + if (dev->data->dev_started) { + RTE_MLDEV_LOG(ERR, "Device %d must be stopped to allow configuration", dev_id); + return -EBUSY; + } + + return (*dev->dev_ops->dev_queue_pair_setup)(dev, queue_pair_id, qp_conf, socket_id); +} + RTE_LOG_REGISTER_DEFAULT(rte_ml_dev_logtype, INFO); diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index dc79c5f630..f8d247b43e 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -113,6 +113,44 @@ typedef int (*mldev_start_t)(struct rte_ml_dev *dev); */ typedef int (*mldev_stop_t)(struct rte_ml_dev *dev); +/** + * @internal + * + * Setup a queue pair for a device. + * + * @param dev + * ML device pointer. + * @param queue_pair_id + * Queue pair index. + * @param queue_pair_conf + * Queue pair configuration structure. + * @param socket_id + * Socket index. + * + * @return + * - 0 on success. + * - < 0, error on failure. + */ +typedef int (*mldev_queue_pair_setup_t)(struct rte_ml_dev *dev, uint16_t queue_pair_id, + const struct rte_ml_dev_qp_conf *queue_pair_conf, + int socket_id); + +/** + * @internal + * + * Release memory resources allocated by given queue pair. + * + * @param dev + * ML device pointer. + * @param queue_pair_id + * Queue pair index. + * + * @return + * - 0 on success. + * - -EAGAIN, if can't close as device is busy. + */ +typedef int (*mldev_queue_pair_release_t)(struct rte_ml_dev *dev, uint16_t queue_pair_id); + /** * @internal * @@ -133,6 +171,12 @@ struct rte_ml_dev_ops { /** Stop device. */ mldev_stop_t dev_stop; + + /** Set up a device queue pair. */ + mldev_queue_pair_setup_t dev_queue_pair_setup; + + /** Release a device queue pair. */ + mldev_queue_pair_release_t dev_queue_pair_release; }; /** diff --git a/lib/mldev/version.map b/lib/mldev/version.map index 028b6a464d..fcf48f1760 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -8,6 +8,7 @@ EXPERIMENTAL { rte_ml_dev_init; rte_ml_dev_is_valid_dev; rte_ml_dev_logtype; + rte_ml_dev_queue_pair_setup; rte_ml_dev_socket_id; rte_ml_dev_start; rte_ml_dev_stop; From patchwork Tue Feb 7 15:13:09 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 123261 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 2EB3F41C30; Tue, 7 Feb 2023 16:14:14 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id A2EA342D30; Tue, 7 Feb 2023 16:13:53 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id 09AC542D1D for ; Tue, 7 Feb 2023 16:13:51 +0100 (CET) Received: from pps.filterd (m0045849.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 317Egcp3017290; Tue, 7 Feb 2023 07:13:51 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=GJVmd5iUL+JEuv759jFyj2Pjjld8E5+/MS9EsbL6RVY=; b=gwm4mhdIDlR8W1+THFyYm+mnY93wktwavvhRVwEh4i2y5FZoj5QPktiYROj1qlHuGL1O JLIma8JxUEiWVwXXYzqIK406LSfE9PKVlEPcX9XDbBKb1dk+kGoXk5plmql7O90iYe9c BTBsvForT59gPcR5M7MEOod0mdhXr2upygRn7b01pDpdLq6ItJekMZ3LPILzf6O7MYmd rkB1hc2d6zxdTVZnuQU4cK4xpbj/x7XjoruhhfyDJ+EB7dx689Dtr8f91IctEO9TFkwQ eCXkxI6mSmVKhZZ106m9RFf8pjPo3lMIOvx6TCtxljc28vMDu/yrBOY4kBru3thFqJq/ Yg== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3nkdyrsk2j-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Tue, 07 Feb 2023 07:13:51 -0800 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.42; Tue, 7 Feb 2023 07:13:49 -0800 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.42 via Frontend Transport; Tue, 7 Feb 2023 07:13:49 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id BD1F13F7089; Tue, 7 Feb 2023 07:13:46 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v3 05/12] mldev: support handling ML models Date: Tue, 7 Feb 2023 20:43:09 +0530 Message-ID: <20230207151316.835441-6-jerinj@marvell.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230207151316.835441-1-jerinj@marvell.com> References: <20230206202453.336280-1-jerinj@marvell.com> <20230207151316.835441-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: HNs2UaRXyjHI6JCSR9MZaSt-CBGyA87K X-Proofpoint-GUID: HNs2UaRXyjHI6JCSR9MZaSt-CBGyA87K X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-07_07,2023-02-06_03,2022-06-22_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Srikanth Yalavarthi Added RTE functions to handle ML models. These APIs can load, unload, start, and stop an ML model. Additional APIs to update model parameters and get model information are added. Signed-off-by: Srikanth Yalavarthi Signed-off-by: Jerin Jacob --- lib/mldev/rte_mldev.c | 123 +++++++++++++++++++++++++++++++++++++ lib/mldev/rte_mldev_core.h | 122 ++++++++++++++++++++++++++++++++++++ lib/mldev/version.map | 6 ++ 3 files changed, 251 insertions(+) diff --git a/lib/mldev/rte_mldev.c b/lib/mldev/rte_mldev.c index 928ea90ab5..9642e62815 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -385,4 +385,127 @@ rte_ml_dev_queue_pair_setup(int16_t dev_id, uint16_t queue_pair_id, return (*dev->dev_ops->dev_queue_pair_setup)(dev, queue_pair_id, qp_conf, socket_id); } +int +rte_ml_model_load(int16_t dev_id, struct rte_ml_model_params *params, uint16_t *model_id) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->model_load == NULL) + return -ENOTSUP; + + if (params == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, params cannot be NULL\n", dev_id); + return -EINVAL; + } + + if (model_id == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, model_id cannot be NULL\n", dev_id); + return -EINVAL; + } + + return (*dev->dev_ops->model_load)(dev, params, model_id); +} + +int +rte_ml_model_unload(int16_t dev_id, uint16_t model_id) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->model_unload == NULL) + return -ENOTSUP; + + return (*dev->dev_ops->model_unload)(dev, model_id); +} + +int +rte_ml_model_start(int16_t dev_id, uint16_t model_id) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->model_start == NULL) + return -ENOTSUP; + + return (*dev->dev_ops->model_start)(dev, model_id); +} + +int +rte_ml_model_stop(int16_t dev_id, uint16_t model_id) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->model_stop == NULL) + return -ENOTSUP; + + return (*dev->dev_ops->model_stop)(dev, model_id); +} + +int +rte_ml_model_info_get(int16_t dev_id, uint16_t model_id, struct rte_ml_model_info *model_info) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->model_info_get == NULL) + return -ENOTSUP; + + if (model_info == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, model_id %u, model_info cannot be NULL\n", dev_id, + model_id); + return -EINVAL; + } + + return (*dev->dev_ops->model_info_get)(dev, model_id, model_info); +} + +int +rte_ml_model_params_update(int16_t dev_id, uint16_t model_id, void *buffer) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->model_params_update == NULL) + return -ENOTSUP; + + if (buffer == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, buffer cannot be NULL\n", dev_id); + return -EINVAL; + } + + return (*dev->dev_ops->model_params_update)(dev, model_id, buffer); +} + RTE_LOG_REGISTER_DEFAULT(rte_ml_dev_logtype, INFO); diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index f8d247b43e..602f541589 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -151,6 +151,110 @@ typedef int (*mldev_queue_pair_setup_t)(struct rte_ml_dev *dev, uint16_t queue_p */ typedef int (*mldev_queue_pair_release_t)(struct rte_ml_dev *dev, uint16_t queue_pair_id); +/** + * @internal + * + * Function used to load an ML model. + * + * @param dev + * ML device pointer. + * @param params + * Model load params. + * @param model_id + * Model ID returned by the library. + * + * @return + * - 0 on success. + * - < 0, error on failure. + */ +typedef int (*mldev_model_load_t)(struct rte_ml_dev *dev, struct rte_ml_model_params *params, + uint16_t *model_id); + +/** + * @internal + * + * Function used to unload an ML model. + * + * @param dev + * ML device pointer. + * @param model_id + * Model ID to use. + * + * @return + * - 0 on success. + * - < 0, error on failure. + */ +typedef int (*mldev_model_unload_t)(struct rte_ml_dev *dev, uint16_t model_id); + +/** + * @internal + * + * Function used to start an ML model. + * + * @param dev + * ML device pointer. + * @param model_id + * Model ID to use. + * + * @return + * - 0 on success. + * - <0, error on failure. + */ +typedef int (*mldev_model_start_t)(struct rte_ml_dev *dev, uint16_t model_id); + +/** + * @internal + * + * Function used to stop an ML model. + * + * @param dev + * ML device pointer. + * @param model_id + * Model ID to use. + * + * @return + * - 0 on success. + * - <0, error on failure. + */ +typedef int (*mldev_model_stop_t)(struct rte_ml_dev *dev, uint16_t model_id); + +/** + * @internal + * + * Get info about a model. + * + * @param dev + * ML device pointer. + * @param model_id + * Model ID to use. + * @param model_info + * Pointer to model info structure. + * + * @return + * - 0 on success. + * - <0, error on failure. + */ +typedef int (*mldev_model_info_get_t)(struct rte_ml_dev *dev, uint16_t model_id, + struct rte_ml_model_info *model_info); + +/** + * @internal + * + * Update model params. + * + * @param dev + * ML device pointer. + * @param model_id + * Model ID to use. + * @param buffer + * Pointer to model params. + * + * @return + * - 0 on success. + * - <0, error on failure. + */ +typedef int (*mldev_model_params_update_t)(struct rte_ml_dev *dev, uint16_t model_id, void *buffer); + /** * @internal * @@ -177,6 +281,24 @@ struct rte_ml_dev_ops { /** Release a device queue pair. */ mldev_queue_pair_release_t dev_queue_pair_release; + + /** Load an ML model. */ + mldev_model_load_t model_load; + + /** Unload an ML model. */ + mldev_model_unload_t model_unload; + + /** Start an ML model. */ + mldev_model_start_t model_start; + + /** Stop an ML model. */ + mldev_model_stop_t model_stop; + + /** Get model information. */ + mldev_model_info_get_t model_info_get; + + /** Update model params. */ + mldev_model_params_update_t model_params_update; }; /** diff --git a/lib/mldev/version.map b/lib/mldev/version.map index fcf48f1760..8da70f2443 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -12,6 +12,12 @@ EXPERIMENTAL { rte_ml_dev_socket_id; rte_ml_dev_start; rte_ml_dev_stop; + rte_ml_model_info_get; + rte_ml_model_load; + rte_ml_model_params_update; + rte_ml_model_start; + rte_ml_model_stop; + rte_ml_model_unload; local: *; }; From patchwork Tue Feb 7 15:13:10 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 123262 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 3AEA841C30; Tue, 7 Feb 2023 16:14:21 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id BA23D42D29; Tue, 7 Feb 2023 16:13:57 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 056A742D38 for ; Tue, 7 Feb 2023 16:13:55 +0100 (CET) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 317BJhJn017823; Tue, 7 Feb 2023 07:13:55 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=VCQbREmgf1DY/HvbMRW1FU88wqMUtSCurwMgrbACnRc=; b=Ybe7jiKRv1xrxgGglI+L4mfYW4R3ZECZxhfRUQrREf4r2cJgdk80xnozE2tAxO/V7ba4 3haotOcdE3I6tZW6s1XghEbefoBG2FXYKmbdYuuxfq50b/t765u87mvGIPz+bw3oyFdb 14H3fmysBNmdSA8F/WGZhEoG55JK0L3vnY1MxGr/3yk/pfpY0aRZ3SIW+XTnxNSWpv6d Zpyc4vjJeuuIL4j4QHxrwNNYemOGa36IXMBjg6Htstqg6kmRBFO8SSJcQjDYFtzK7FVU IbvPYsk4UYD5jyY5OS50E7XOj7ExMPMhkvNR2WpwESagfYcvhSc6G5PuAKcpI2gsr1tQ 9w== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3nhqrtme5v-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Tue, 07 Feb 2023 07:13:55 -0800 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.42; Tue, 7 Feb 2023 07:13:53 -0800 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.42 via Frontend Transport; Tue, 7 Feb 2023 07:13:53 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id 8EDDB3F7083; Tue, 7 Feb 2023 07:13:50 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v3 06/12] mldev: support input and output data handling Date: Tue, 7 Feb 2023 20:43:10 +0530 Message-ID: <20230207151316.835441-7-jerinj@marvell.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230207151316.835441-1-jerinj@marvell.com> References: <20230206202453.336280-1-jerinj@marvell.com> <20230207151316.835441-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: aTOxl_lh-XGNYAkbbnRAi2wfwcJ_5GG9 X-Proofpoint-ORIG-GUID: aTOxl_lh-XGNYAkbbnRAi2wfwcJ_5GG9 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-07_07,2023-02-06_03,2022-06-22_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Srikanth Yalavarthi Added library functions to handle model input and output data. The APIs can be used to get the size of I/O buffers, quantize input data and dequantize output data. Signed-off-by: Srikanth Yalavarthi Signed-off-by: Jerin Jacob --- lib/mldev/rte_mldev.c | 94 ++++++++++++++++++++++++++++++++ lib/mldev/rte_mldev_core.h | 106 +++++++++++++++++++++++++++++++++++++ lib/mldev/version.map | 4 ++ 3 files changed, 204 insertions(+) diff --git a/lib/mldev/rte_mldev.c b/lib/mldev/rte_mldev.c index 9642e62815..f9684e90ea 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -508,4 +508,98 @@ rte_ml_model_params_update(int16_t dev_id, uint16_t model_id, void *buffer) return (*dev->dev_ops->model_params_update)(dev, model_id, buffer); } +int +rte_ml_io_input_size_get(int16_t dev_id, uint16_t model_id, uint32_t nb_batches, + uint64_t *input_qsize, uint64_t *input_dsize) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->io_input_size_get == NULL) + return -ENOTSUP; + + return (*dev->dev_ops->io_input_size_get)(dev, model_id, nb_batches, input_qsize, + input_dsize); +} + +int +rte_ml_io_output_size_get(int16_t dev_id, uint16_t model_id, uint32_t nb_batches, + uint64_t *output_qsize, uint64_t *output_dsize) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->io_output_size_get == NULL) + return -ENOTSUP; + + return (*dev->dev_ops->io_output_size_get)(dev, model_id, nb_batches, output_qsize, + output_dsize); +} + +int +rte_ml_io_quantize(int16_t dev_id, uint16_t model_id, uint16_t nb_batches, void *dbuffer, + void *qbuffer) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->io_quantize == NULL) + return -ENOTSUP; + + if (dbuffer == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, dbuffer cannot be NULL\n", dev_id); + return -EINVAL; + } + + if (qbuffer == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, qbuffer cannot be NULL\n", dev_id); + return -EINVAL; + } + + return (*dev->dev_ops->io_quantize)(dev, model_id, nb_batches, dbuffer, qbuffer); +} + +int +rte_ml_io_dequantize(int16_t dev_id, uint16_t model_id, uint16_t nb_batches, void *qbuffer, + void *dbuffer) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->io_dequantize == NULL) + return -ENOTSUP; + + if (qbuffer == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, qbuffer cannot be NULL\n", dev_id); + return -EINVAL; + } + + if (dbuffer == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, dbuffer cannot be NULL\n", dev_id); + return -EINVAL; + } + + return (*dev->dev_ops->io_dequantize)(dev, model_id, nb_batches, qbuffer, dbuffer); +} + RTE_LOG_REGISTER_DEFAULT(rte_ml_dev_logtype, INFO); diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index 602f541589..46e6e7a4e5 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -255,6 +255,100 @@ typedef int (*mldev_model_info_get_t)(struct rte_ml_dev *dev, uint16_t model_id, */ typedef int (*mldev_model_params_update_t)(struct rte_ml_dev *dev, uint16_t model_id, void *buffer); +/** + * @internal + * + * Get size of input buffers. + * + * @param dev + * ML device pointer. + * @param model_id + * Model ID to use. + * @param nb_batches + * Number of batches. + * @param input_qsize + * Size of quantized input. + * @param input_dsize + * Size of dequantized input. + * + * @return + * - 0 on success. + * - <0, error on failure. + */ +typedef int (*mldev_io_input_size_get_t)(struct rte_ml_dev *dev, uint16_t model_id, + uint32_t nb_batches, uint64_t *input_qsize, + uint64_t *input_dsize); + +/** + * @internal + * + * Get size of output buffers. + * + * @param dev + * ML device pointer. + * @param model_id + * Model ID to use. + * @param nb_batches + * Number of batches. + * @param output_qsize + * Size of quantized output. + * @param output_dsize + * Size of dequantized output. + * + * @return + * - 0 on success. + * - <0, error on failure. + */ +typedef int (*mldev_io_output_size_get_t)(struct rte_ml_dev *dev, uint16_t model_id, + uint32_t nb_batches, uint64_t *output_qsize, + uint64_t *output_dsize); + +/** + * @internal + * + * Quantize model data. + * + * @param dev + * ML device pointer. + * @param model_id + * Model ID to use. + * @param nb_batches + * Number of batches. + * @param dbuffer + * Pointer t de-quantized data buffer. + * @param qbuffer + * Pointer t de-quantized data buffer. + * + * @return + * - 0 on success. + * - <0, error on failure. + */ +typedef int (*mldev_io_quantize_t)(struct rte_ml_dev *dev, uint16_t model_id, uint16_t nb_batches, + void *dbuffer, void *qbuffer); + +/** + * @internal + * + * Quantize model data. + * + * @param dev + * ML device pointer. + * @param model_id + * Model ID to use. + * @param nb_batches + * Number of batches. + * @param qbuffer + * Pointer t de-quantized data buffer. + * @param dbuffer + * Pointer t de-quantized data buffer. + * + * @return + * - 0 on success. + * - <0, error on failure. + */ +typedef int (*mldev_io_dequantize_t)(struct rte_ml_dev *dev, uint16_t model_id, uint16_t nb_batches, + void *qbuffer, void *dbuffer); + /** * @internal * @@ -299,6 +393,18 @@ struct rte_ml_dev_ops { /** Update model params. */ mldev_model_params_update_t model_params_update; + + /** Get input buffer size. */ + mldev_io_input_size_get_t io_input_size_get; + + /** Get output buffer size. */ + mldev_io_output_size_get_t io_output_size_get; + + /** Quantize data */ + mldev_io_quantize_t io_quantize; + + /** De-quantize data */ + mldev_io_dequantize_t io_dequantize; }; /** diff --git a/lib/mldev/version.map b/lib/mldev/version.map index 8da70f2443..d65b0792ab 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -12,6 +12,10 @@ EXPERIMENTAL { rte_ml_dev_socket_id; rte_ml_dev_start; rte_ml_dev_stop; + rte_ml_io_dequantize; + rte_ml_io_input_size_get; + rte_ml_io_output_size_get; + rte_ml_io_quantize; rte_ml_model_info_get; rte_ml_model_load; rte_ml_model_params_update; From patchwork Tue Feb 7 15:13:11 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 123263 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id BD83041C30; Tue, 7 Feb 2023 16:14:27 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id B510042D2F; Tue, 7 Feb 2023 16:14:00 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id 6A25E42D2F for ; Tue, 7 Feb 2023 16:13:59 +0100 (CET) Received: from pps.filterd (m0045849.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 317EYvXU001487; Tue, 7 Feb 2023 07:13:58 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=rIpTIyswQp8PspQcazsE6FjGPzvK+K0oTQqGrKlzQFs=; b=E1w/Dp3Kz+Lok6MrjUOjhUwYk/RwTgnSzAvZ5uzrqxh26FAb5+aLAXATS1G+hVfFXNBj iITGttRqShgPRW/Dccz/lFNU4cYmvbz6RyswFbf1GqiFeDsRVXJdySWKfN+q10dFhvda KN2dowMCQ9twDPDI83hdhZtQx3HxWhPukVlAnPYkE0UxcKDE1PIMJ5bS830DllgAkaed VreSBJKiLiFcIZ8igLwB6fHrCwa1DgRL5tl98sl3Yt4YecPqmA7akq9GnhOp4SBDfqbh ohbDP46ojzjy6OfK116aC19yc2JMe2m9xZaEK7IUfD4lPtPvpahjBV1dlcD2LNw+ykkh LA== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3nkdyrsk33-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Tue, 07 Feb 2023 07:13:58 -0800 Received: from DC5-EXCH01.marvell.com (10.69.176.38) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.42; Tue, 7 Feb 2023 07:13:56 -0800 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server id 15.0.1497.42 via Frontend Transport; Tue, 7 Feb 2023 07:13:56 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id 57E943F7082; Tue, 7 Feb 2023 07:13:54 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v3 07/12] mldev: support ML op pool and ops Date: Tue, 7 Feb 2023 20:43:11 +0530 Message-ID: <20230207151316.835441-8-jerinj@marvell.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230207151316.835441-1-jerinj@marvell.com> References: <20230206202453.336280-1-jerinj@marvell.com> <20230207151316.835441-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: UyA9CFxA9iLVVZ231avn5D2Ye0XBP4eA X-Proofpoint-GUID: UyA9CFxA9iLVVZ231avn5D2Ye0XBP4eA X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-07_07,2023-02-06_03,2022-06-22_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Srikanth Yalavarthi Added library functions to create and free ML op pool. Create function allocates new ML op pool and initializes ML ops to their defaults. Signed-off-by: Srikanth Yalavarthi Signed-off-by: Jerin Jacob --- lib/mldev/rte_mldev.c | 69 +++++++++++++++++++++++++++++++++++++++++++ lib/mldev/version.map | 2 ++ 2 files changed, 71 insertions(+) diff --git a/lib/mldev/rte_mldev.c b/lib/mldev/rte_mldev.c index f9684e90ea..da65819c08 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -12,6 +12,17 @@ static struct rte_ml_dev_global ml_dev_globals = { .devs = NULL, .data = NULL, .nb_devs = 0, .max_devs = RTE_MLDEV_DEFAULT_MAX}; +/* + * Private data structure of an operation pool. + * + * A structure that contains ml op_pool specific data that is + * appended after the mempool structure (in private data). + */ +struct rte_ml_op_pool_private { + uint16_t user_size; + /*< Size of private user data with each operation. */ +}; + struct rte_ml_dev * rte_ml_dev_pmd_get_dev(int16_t dev_id) { @@ -602,4 +613,62 @@ rte_ml_io_dequantize(int16_t dev_id, uint16_t model_id, uint16_t nb_batches, voi return (*dev->dev_ops->io_dequantize)(dev, model_id, nb_batches, qbuffer, dbuffer); } +/** Initialise rte_ml_op mempool element */ +static void +ml_op_init(struct rte_mempool *mempool, __rte_unused void *opaque_arg, void *_op_data, + __rte_unused unsigned int i) +{ + struct rte_ml_op *op = _op_data; + + memset(_op_data, 0, mempool->elt_size); + op->status = RTE_ML_OP_STATUS_NOT_PROCESSED; + op->mempool = mempool; +} + +struct rte_mempool * +rte_ml_op_pool_create(const char *name, unsigned int nb_elts, unsigned int cache_size, + uint16_t user_size, int socket_id) +{ + struct rte_ml_op_pool_private *priv; + struct rte_mempool *mp; + unsigned int elt_size; + + /* lookup mempool in case already allocated */ + mp = rte_mempool_lookup(name); + elt_size = sizeof(struct rte_ml_op) + user_size; + + if (mp != NULL) { + priv = (struct rte_ml_op_pool_private *)rte_mempool_get_priv(mp); + if (mp->elt_size != elt_size || mp->cache_size < cache_size || mp->size < nb_elts || + priv->user_size < user_size) { + mp = NULL; + RTE_MLDEV_LOG(ERR, + "Mempool %s already exists but with incompatible parameters", + name); + return NULL; + } + return mp; + } + + mp = rte_mempool_create(name, nb_elts, elt_size, cache_size, + sizeof(struct rte_ml_op_pool_private), NULL, NULL, ml_op_init, NULL, + socket_id, 0); + if (mp == NULL) { + RTE_MLDEV_LOG(ERR, "Failed to create mempool %s", name); + return NULL; + } + + priv = (struct rte_ml_op_pool_private *)rte_mempool_get_priv(mp); + priv->user_size = user_size; + + return mp; +} + +void +rte_ml_op_pool_free(struct rte_mempool *mempool) +{ + if (mempool != NULL) + rte_mempool_free(mempool); +} + RTE_LOG_REGISTER_DEFAULT(rte_ml_dev_logtype, INFO); diff --git a/lib/mldev/version.map b/lib/mldev/version.map index d65b0792ab..7665226d0e 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -22,6 +22,8 @@ EXPERIMENTAL { rte_ml_model_start; rte_ml_model_stop; rte_ml_model_unload; + rte_ml_op_pool_create; + rte_ml_op_pool_free; local: *; }; From patchwork Tue Feb 7 15:13:12 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 123264 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id BA4F741C30; Tue, 7 Feb 2023 16:14:34 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 30EDE4282D; Tue, 7 Feb 2023 16:14:05 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id 636CF4282D for ; Tue, 7 Feb 2023 16:14:03 +0100 (CET) Received: from pps.filterd (m0045849.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 317EgVPP017206; Tue, 7 Feb 2023 07:14:02 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=JDSgWVX+N/lS2DLqacWqnOWA5ZG8eWF4LAqA+8arp0M=; b=YV6rgEA9OuPVQrOUPcsqViaUyfyx4stnomUGBAo0rdO9cDFJ4HxuniCFcUivMoJ90qh6 J5Y4ZvpKOg1DIz48hsGm0G5+IgecYZrvU5LYhRqLF2Jftb33dbtzs5ORMIc3VEd+KvJt W369Rj2L/WltUb4EKIyIl8ngS3vtlmYtEnrjGLkhs8l/4XmwN8wfl2/5qVv4mT0XFl1t beio+NwWQStqUbjinMBYoaoSnRMGv89ZE52+8U2j2ZGfM1xsFDgjWIxi37vESPEAQZW6 g9nB2PnbLn37B0UPDrKSBPVECIhqm/UcNzZmqASpjeVNrEEf9Mc9CtkjVKbf3vTWIUCH uA== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3nkdyrsk3g-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Tue, 07 Feb 2023 07:14:02 -0800 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.42; Tue, 7 Feb 2023 07:14:00 -0800 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.42 via Frontend Transport; Tue, 7 Feb 2023 07:14:00 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id 338D53F7082; Tue, 7 Feb 2023 07:13:57 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v3 08/12] mldev: support inference enqueue and dequeue Date: Tue, 7 Feb 2023 20:43:12 +0530 Message-ID: <20230207151316.835441-9-jerinj@marvell.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230207151316.835441-1-jerinj@marvell.com> References: <20230206202453.336280-1-jerinj@marvell.com> <20230207151316.835441-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: GWXhEG916ZGxYfuEMmNtjbQX8glFDW5X X-Proofpoint-GUID: GWXhEG916ZGxYfuEMmNtjbQX8glFDW5X X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-07_07,2023-02-06_03,2022-06-22_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Srikanth Yalavarthi Added implementations of fast-path functions to enqueue and dequeue ML requests from an ML device queue-pair. Signed-off-by: Srikanth Yalavarthi Signed-off-by: Jerin Jacob --- lib/mldev/rte_mldev.c | 75 ++++++++++++++++++++++++++++++++++++++ lib/mldev/rte_mldev_core.h | 46 +++++++++++++++++++++++ lib/mldev/rte_mldev_pmd.h | 2 + lib/mldev/version.map | 2 + 4 files changed, 125 insertions(+) diff --git a/lib/mldev/rte_mldev.c b/lib/mldev/rte_mldev.c index da65819c08..184d87c70a 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -114,6 +114,9 @@ rte_ml_dev_pmd_allocate(const char *name, uint8_t socket_id) ml_dev_globals.nb_devs++; } + dev->enqueue_burst = NULL; + dev->dequeue_burst = NULL; + return dev; } @@ -671,4 +674,76 @@ rte_ml_op_pool_free(struct rte_mempool *mempool) rte_mempool_free(mempool); } +uint16_t +rte_ml_enqueue_burst(int16_t dev_id, uint16_t qp_id, struct rte_ml_op **ops, uint16_t nb_ops) +{ + struct rte_ml_dev *dev; + +#ifdef RTE_LIBRTE_ML_DEV_DEBUG + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + rte_errno = -EINVAL; + return 0; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->enqueue_burst == NULL) { + rte_errno = -ENOTSUP; + return 0; + } + + if (ops == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, ops cannot be NULL\n", dev_id); + rte_errno = -EINVAL; + return 0; + } + + if (qp_id >= dev->data->nb_queue_pairs) { + RTE_MLDEV_LOG(ERR, "Invalid qp_id %u\n", qp_id); + rte_errno = -EINVAL; + return 0; + } +#else + dev = rte_ml_dev_pmd_get_dev(dev_id); +#endif + + return (*dev->enqueue_burst)(dev, qp_id, ops, nb_ops); +} + +uint16_t +rte_ml_dequeue_burst(int16_t dev_id, uint16_t qp_id, struct rte_ml_op **ops, uint16_t nb_ops) +{ + struct rte_ml_dev *dev; + +#ifdef RTE_LIBRTE_ML_DEV_DEBUG + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + rte_errno = -EINVAL; + return 0; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dequeue_burst == NULL) { + rte_errno = -ENOTSUP; + return 0; + } + + if (ops == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, ops cannot be NULL\n", dev_id); + rte_errno = -EINVAL; + return 0; + } + + if (qp_id >= dev->data->nb_queue_pairs) { + RTE_MLDEV_LOG(ERR, "Invalid qp_id %u\n", qp_id); + rte_errno = -EINVAL; + return 0; + } +#else + dev = rte_ml_dev_pmd_get_dev(dev_id); +#endif + + return (*dev->dequeue_burst)(dev, qp_id, ops, nb_ops); +} + RTE_LOG_REGISTER_DEFAULT(rte_ml_dev_logtype, INFO); diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index 46e6e7a4e5..1c02813c87 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -33,6 +33,46 @@ extern "C" { struct rte_ml_dev; +/** + * @internal + * + * Enqueue a burst of inference requests to a queue on ML device. + * + * @param dev + * ML device pointer. + * @param qp_id + * Queue-pair ID. + * @param ops + * Array of ML ops to be enqueued. + * @param nb_ops + * Number of ops to enqueue. + * + * @return + * - Number of ops enqueued. + */ +typedef uint16_t (*mldev_enqueue_t)(struct rte_ml_dev *dev, uint16_t qp_id, struct rte_ml_op **ops, + uint16_t nb_ops); + +/** + * @internal + * + * Dequeue a burst of inference requests from a queue on ML device. + * + * @param dev + * ML device pointer. + * @param qp_id + * Queue-pair ID. + * @param ops + * Array of ML ops to dequeued. + * @param nb_ops + * Number of ops to dequeue. + * + * @return + * - Number of ops dequeued. + */ +typedef uint16_t (*mldev_dequeue_t)(struct rte_ml_dev *dev, uint16_t qp_id, struct rte_ml_op **ops, + uint16_t nb_ops); + /** * Definitions of all functions exported by a driver through the generic structure of type * *ml_dev_ops* supplied in the *rte_ml_dev* structure associated with a device. @@ -448,6 +488,12 @@ struct rte_ml_dev_data { * The data structure associated with each ML device. */ struct rte_ml_dev { + /** Pointer to PMD enqueue function. */ + mldev_enqueue_t enqueue_burst; + + /** Pointer to PMD dequeue function. */ + mldev_dequeue_t dequeue_burst; + /** Pointer to device data. */ struct rte_ml_dev_data *data; diff --git a/lib/mldev/rte_mldev_pmd.h b/lib/mldev/rte_mldev_pmd.h index 33544f1b80..afe617e4bf 100644 --- a/lib/mldev/rte_mldev_pmd.h +++ b/lib/mldev/rte_mldev_pmd.h @@ -40,6 +40,8 @@ struct rte_ml_dev_pmd_init_params { uint64_t private_data_size; }; +struct rte_ml_dev; + /** * @internal * diff --git a/lib/mldev/version.map b/lib/mldev/version.map index 7665226d0e..e6b1ac4a4d 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -1,6 +1,7 @@ EXPERIMENTAL { global: + rte_ml_dequeue_burst; rte_ml_dev_close; rte_ml_dev_configure; rte_ml_dev_count; @@ -12,6 +13,7 @@ EXPERIMENTAL { rte_ml_dev_socket_id; rte_ml_dev_start; rte_ml_dev_stop; + rte_ml_enqueue_burst; rte_ml_io_dequantize; rte_ml_io_input_size_get; rte_ml_io_output_size_get; From patchwork Tue Feb 7 15:13:13 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 123265 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id A9AF941C30; Tue, 7 Feb 2023 16:14:43 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id B834642D4B; Tue, 7 Feb 2023 16:14:08 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 3718E42D2D for ; Tue, 7 Feb 2023 16:14:07 +0100 (CET) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 317BEAGr015844; Tue, 7 Feb 2023 07:14:06 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=ZAJjkHVrzndW0a+ii+dkJKnzSm3PF3P4OuDmGke28n4=; b=DT2d2Z4zbv/oxVlZLoQgBtjxj8BgDhBLYcLiFH8QFmpk9BlCpdjetRZJv3hcyci26sYB BJ9Ypxcnqj/zsrKmX1nsNrd4WPLRZwlXK8uoOAA5bDUqlbfJCe1N9O/3ytdOfzevKAxU V1xEE4oyMaUzB9u0VjW56iHNeupKfdRsg9VFW7nOBOJVFRqVsDpnZtazN12iTE0/Ggqy cZyjwjdZNR8WipYfUTTriNl/yZMn88CW+L25c8Orl4Z61JO9iOy5/G0WbK0zFMjAFKHS jEZCrtYTiwxmKY5WaYmZ6Obi+prW5mxCb0GP5IyMeAfozn5M84RjIF0iI5faiGMImIW9 Rg== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3nhqrtme70-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Tue, 07 Feb 2023 07:14:06 -0800 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.42; Tue, 7 Feb 2023 07:14:04 -0800 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.42 via Frontend Transport; Tue, 7 Feb 2023 07:14:04 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id D9D083F7085; Tue, 7 Feb 2023 07:14:01 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v3 09/12] mldev: support device statistics Date: Tue, 7 Feb 2023 20:43:13 +0530 Message-ID: <20230207151316.835441-10-jerinj@marvell.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230207151316.835441-1-jerinj@marvell.com> References: <20230206202453.336280-1-jerinj@marvell.com> <20230207151316.835441-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: w6p25P4ry3DaE6Uw8MGvAyoC3ZzB6bVH X-Proofpoint-ORIG-GUID: w6p25P4ry3DaE6Uw8MGvAyoC3ZzB6bVH X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-07_07,2023-02-06_03,2022-06-22_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Srikanth Yalavarthi Added functions to get and reset device stats. Device stats include number of requests enqueued, dequeued and errors. Added function prototypes to used by driver implementations. Signed-off-by: Srikanth Yalavarthi Signed-off-by: Jerin Jacob --- lib/mldev/rte_mldev.c | 40 ++++++++++++++++++++++++++++++++++++++ lib/mldev/rte_mldev_core.h | 32 ++++++++++++++++++++++++++++++ lib/mldev/version.map | 2 ++ 3 files changed, 74 insertions(+) diff --git a/lib/mldev/rte_mldev.c b/lib/mldev/rte_mldev.c index 184d87c70a..f096ed2bc3 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -399,6 +399,46 @@ rte_ml_dev_queue_pair_setup(int16_t dev_id, uint16_t queue_pair_id, return (*dev->dev_ops->dev_queue_pair_setup)(dev, queue_pair_id, qp_conf, socket_id); } +int +rte_ml_dev_stats_get(int16_t dev_id, struct rte_ml_dev_stats *stats) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->dev_stats_get == NULL) + return -ENOTSUP; + + if (stats == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, stats cannot be NULL\n", dev_id); + return -EINVAL; + } + memset(stats, 0, sizeof(struct rte_ml_dev_stats)); + + return (*dev->dev_ops->dev_stats_get)(dev, stats); +} + +void +rte_ml_dev_stats_reset(int16_t dev_id) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->dev_stats_reset == NULL) + return; + + (*dev->dev_ops->dev_stats_reset)(dev); +} + int rte_ml_model_load(int16_t dev_id, struct rte_ml_model_params *params, uint16_t *model_id) { diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index 1c02813c87..7c9877731e 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -191,6 +191,32 @@ typedef int (*mldev_queue_pair_setup_t)(struct rte_ml_dev *dev, uint16_t queue_p */ typedef int (*mldev_queue_pair_release_t)(struct rte_ml_dev *dev, uint16_t queue_pair_id); +/** + * @internal + * + * Function used to get device statistics. + * + * @param dev + * ML device pointer. + * @param stats + * Pointer to ML device stats structure to update. + * + * @return + * - 0 on success. + * - < 0, error on failure. + */ +typedef int (*mldev_stats_get_t)(struct rte_ml_dev *dev, struct rte_ml_dev_stats *stats); + +/** + * @internal + * + * Function used to reset device statistics. + * + * @param dev + * ML device pointer. + */ +typedef void (*mldev_stats_reset_t)(struct rte_ml_dev *dev); + /** * @internal * @@ -416,6 +442,12 @@ struct rte_ml_dev_ops { /** Release a device queue pair. */ mldev_queue_pair_release_t dev_queue_pair_release; + /** Get device statistics. */ + mldev_stats_get_t dev_stats_get; + + /** Reset device statistics. */ + mldev_stats_reset_t dev_stats_reset; + /** Load an ML model. */ mldev_model_load_t model_load; diff --git a/lib/mldev/version.map b/lib/mldev/version.map index e6b1ac4a4d..7c652f1f9b 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -12,6 +12,8 @@ EXPERIMENTAL { rte_ml_dev_queue_pair_setup; rte_ml_dev_socket_id; rte_ml_dev_start; + rte_ml_dev_stats_get; + rte_ml_dev_stats_reset; rte_ml_dev_stop; rte_ml_enqueue_burst; rte_ml_io_dequantize; From patchwork Tue Feb 7 15:13:14 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 123266 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 6289B41C30; Tue, 7 Feb 2023 16:14:50 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 423D742D42; Tue, 7 Feb 2023 16:14:13 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id E1CDB42D2D for ; Tue, 7 Feb 2023 16:14:10 +0100 (CET) Received: from pps.filterd (m0045849.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 317EbXhn006848; Tue, 7 Feb 2023 07:14:10 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=4MvW/Sx105QATfqHuYE/kqfIPjq4T0uGjHxJ644TeY4=; b=XBq6XkW0bXu6YTKzrzTNOc5Hn7ggoxfsShBfXkVThOesvBBGcC+bZR3TZE8uT8KfHNnZ umCVbu+1vfEo/L7JkcAQ6Rh+fwArbb2UAYsS78dINIIb7N8T3CpnHjnupua0I2+NvKhd 00VM8gK6qAD5iPEbckAq13ObBtTOiyI4ayR967iKcjN+pU5XNrUUIgtFinrGm13BwswZ w2hUwPEc9r4phgNf81MXbNBzHh+xUbMQjIRmq90YQdBjZpk8vioKnabqxHrQiZYVSsJP S/uishzhP9vNUAej4+pK4KoizQLx8VS/6han3jsDSWTw8Me2a5rNwPAbN6NViZc8Wang gw== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3nkdyrsk4g-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Tue, 07 Feb 2023 07:14:09 -0800 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.42; Tue, 7 Feb 2023 07:14:08 -0800 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.42 via Frontend Transport; Tue, 7 Feb 2023 07:14:08 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id B1F453F7082; Tue, 7 Feb 2023 07:14:05 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v3 10/12] mldev: support device extended statistics Date: Tue, 7 Feb 2023 20:43:14 +0530 Message-ID: <20230207151316.835441-11-jerinj@marvell.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230207151316.835441-1-jerinj@marvell.com> References: <20230206202453.336280-1-jerinj@marvell.com> <20230207151316.835441-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: Jp8LN37Qu2Hd09c17bMvc_qSwdaKZykW X-Proofpoint-GUID: Jp8LN37Qu2Hd09c17bMvc_qSwdaKZykW X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-07_07,2023-02-06_03,2022-06-22_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Srikanth Yalavarthi Added functions to handle device extended stats. xstats supported are driver specific and can include stats specific to ML device or ML model and I/O. Added prototypes for functions to be called by the device drivers. Signed-off-by: Srikanth Yalavarthi Signed-off-by: Jerin Jacob --- lib/mldev/rte_mldev.c | 88 ++++++++++++++++++++++++++++++++++++ lib/mldev/rte_mldev_core.h | 93 ++++++++++++++++++++++++++++++++++++++ lib/mldev/version.map | 4 ++ 3 files changed, 185 insertions(+) diff --git a/lib/mldev/rte_mldev.c b/lib/mldev/rte_mldev.c index f096ed2bc3..f6c5282f39 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -439,6 +439,94 @@ rte_ml_dev_stats_reset(int16_t dev_id) (*dev->dev_ops->dev_stats_reset)(dev); } +int +rte_ml_dev_xstats_names_get(int16_t dev_id, struct rte_ml_dev_xstats_map *xstats_map, uint32_t size) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->dev_xstats_names_get == NULL) + return -ENOTSUP; + + return (*dev->dev_ops->dev_xstats_names_get)(dev, xstats_map, size); +} + +int +rte_ml_dev_xstats_by_name_get(int16_t dev_id, const char *name, uint16_t *stat_id, uint64_t *value) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->dev_xstats_by_name_get == NULL) + return -ENOTSUP; + + if (name == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, name cannot be NULL\n", dev_id); + return -EINVAL; + } + + if (value == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, value cannot be NULL\n", dev_id); + return -EINVAL; + } + + return (*dev->dev_ops->dev_xstats_by_name_get)(dev, name, stat_id, value); +} + +int +rte_ml_dev_xstats_get(int16_t dev_id, const uint16_t *stat_ids, uint64_t *values, uint16_t nb_ids) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->dev_xstats_get == NULL) + return -ENOTSUP; + + if (stat_ids == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, stat_ids cannot be NULL\n", dev_id); + return -EINVAL; + } + + if (values == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, values cannot be NULL\n", dev_id); + return -EINVAL; + } + + return (*dev->dev_ops->dev_xstats_get)(dev, stat_ids, values, nb_ids); +} + +int +rte_ml_dev_xstats_reset(int16_t dev_id, const uint16_t *stat_ids, uint16_t nb_ids) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->dev_xstats_reset == NULL) + return -ENOTSUP; + + return (*dev->dev_ops->dev_xstats_reset)(dev, stat_ids, nb_ids); +} + int rte_ml_model_load(int16_t dev_id, struct rte_ml_model_params *params, uint16_t *model_id) { diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index 7c9877731e..bc94420000 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -217,6 +217,87 @@ typedef int (*mldev_stats_get_t)(struct rte_ml_dev *dev, struct rte_ml_dev_stats */ typedef void (*mldev_stats_reset_t)(struct rte_ml_dev *dev); +/** + * @internal + * + * Function used to get names of extended stats. + * + * @param dev + * ML device pointer. + * @param xstats_map + * Array to insert id and names into. + * @param size + * Size of xstats_map array. + * + * @return + * - >= 0 and <= size on success. + * - > size, error. Returns the size of xstats_map array required. + * - < 0, error code on failure. + */ +typedef int (*mldev_xstats_names_get_t)(struct rte_ml_dev *dev, + struct rte_ml_dev_xstats_map *xstats_map, uint32_t size); + +/** + * @internal + * + * Function used to get a single extended stat by name. + * + * @param dev + * ML device pointer. + * @param name + * Name of the stat to retrieve. + * @param stat_id + * ID of the stat to be returned. + * @param value + * Value of the stat to be returned. + * + * @return + * - >= 0 stat value. + * - < 0, error code on failure. + */ +typedef int (*mldev_xstats_by_name_get_t)(struct rte_ml_dev *dev, const char *name, + uint16_t *stat_id, uint64_t *value); + +/** + * @internal + * + * Function used to retrieve extended stats of a device. + * + * @param dev + * ML device pointer. + * @param stat_ids + * Array of ID numbers of the stats to be retrieved. + * @param values + * Values of the stats requested by the ID. + * @param nb_ids + * Number of stats requested. + * + * @return + * - >= 0, number of entries filled into the values array. + * - < 0, error code on failure. + */ +typedef int (*mldev_xstats_get_t)(struct rte_ml_dev *dev, const uint16_t *stat_ids, + uint64_t *values, uint16_t nb_ids); + +/** + * @internal + * + * Function used to reset extended stats. + * + * @param dev + * ML device pointer. + * @param stat_ids + * Array of stats IDs to be reset. + * @param nb_ids + * Number of IDs in the stat_ids array. + * + * @return + * - 0 on success. + * - < 0, error code on failure. + */ +typedef int (*mldev_xstats_reset_t)(struct rte_ml_dev *dev, const uint16_t *stat_ids, + uint16_t nb_ids); + /** * @internal * @@ -448,6 +529,18 @@ struct rte_ml_dev_ops { /** Reset device statistics. */ mldev_stats_reset_t dev_stats_reset; + /** Get names of extended stats. */ + mldev_xstats_names_get_t dev_xstats_names_get; + + /** Get value of a single extended stat. */ + mldev_xstats_by_name_get_t dev_xstats_by_name_get; + + /** Get extended stats of a device. */ + mldev_xstats_get_t dev_xstats_get; + + /** Reset extended stats of the device. */ + mldev_xstats_reset_t dev_xstats_reset; + /** Load an ML model. */ mldev_model_load_t model_load; diff --git a/lib/mldev/version.map b/lib/mldev/version.map index 7c652f1f9b..1e7c1ab2b2 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -15,6 +15,10 @@ EXPERIMENTAL { rte_ml_dev_stats_get; rte_ml_dev_stats_reset; rte_ml_dev_stop; + rte_ml_dev_xstats_by_name_get; + rte_ml_dev_xstats_get; + rte_ml_dev_xstats_names_get; + rte_ml_dev_xstats_reset; rte_ml_enqueue_burst; rte_ml_io_dequantize; rte_ml_io_input_size_get; From patchwork Tue Feb 7 15:13:15 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 123267 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 2C51B41C30; Tue, 7 Feb 2023 16:14:57 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 6990542D40; Tue, 7 Feb 2023 16:14:16 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id 7B46440E6E for ; Tue, 7 Feb 2023 16:14:14 +0100 (CET) Received: from pps.filterd (m0045849.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 317EbMa8006803; Tue, 7 Feb 2023 07:14:13 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=OTuPZEONMZxld6LvxMhobXsz2FzE0wWhzAEI4WWsX/E=; b=f9f7fww3CU6XCc01Rac77T6SyxMsLF2Nyb3hk66HkWj6SU1VW/8Njtz89rHBFsf96i/7 PS2FdQmu2anr1/JbTLti2Akb34HDg5zc10TjIOk2lylXYGW+ypGsuf6vsS2c4sl0i0Wn g/RJoOKGreKqjm/E+JzessRCmfBfs78E1pit8L8t3UNgo/y+F1P/wZvbkiY8gw98EVY7 w7ETDiM15zsqP8utnpS5DJwBQTnrA2Z99bfIDx+yhHixZGiQB3A0pLr2QPuo2vX//hIL cG89iQIjwTPfx+B9a1ynMQg3tPs25wV+oMZMzf3IltjAMsLQvYsFedvxBJzBobM08lrs tQ== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3nkdyrsk4y-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Tue, 07 Feb 2023 07:14:13 -0800 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.42; Tue, 7 Feb 2023 07:14:12 -0800 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.42 via Frontend Transport; Tue, 7 Feb 2023 07:14:12 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id 7CA673F7082; Tue, 7 Feb 2023 07:14:09 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v3 11/12] mldev: support to retrieve error information Date: Tue, 7 Feb 2023 20:43:15 +0530 Message-ID: <20230207151316.835441-12-jerinj@marvell.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230207151316.835441-1-jerinj@marvell.com> References: <20230206202453.336280-1-jerinj@marvell.com> <20230207151316.835441-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: 6-pC54SscGFrmHjc_-1RsPyHX_5Ht6ey X-Proofpoint-GUID: 6-pC54SscGFrmHjc_-1RsPyHX_5Ht6ey X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-07_07,2023-02-06_03,2022-06-22_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Srikanth Yalavarthi Added functions to get error information for an ML op. This information can include both drive specific error message and error code. Signed-off-by: Srikanth Yalavarthi Signed-off-by: Jerin Jacob --- lib/mldev/rte_mldev.c | 31 +++++++++++++++++++++++++++++++ lib/mldev/rte_mldev_core.h | 22 ++++++++++++++++++++++ lib/mldev/version.map | 1 + 3 files changed, 54 insertions(+) diff --git a/lib/mldev/rte_mldev.c b/lib/mldev/rte_mldev.c index f6c5282f39..9258f44466 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -874,4 +874,35 @@ rte_ml_dequeue_burst(int16_t dev_id, uint16_t qp_id, struct rte_ml_op **ops, uin return (*dev->dequeue_burst)(dev, qp_id, ops, nb_ops); } +int +rte_ml_op_error_get(int16_t dev_id, struct rte_ml_op *op, struct rte_ml_op_error *error) +{ + struct rte_ml_dev *dev; + +#ifdef RTE_LIBRTE_ML_DEV_DEBUG + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->op_error_get == NULL) + return -ENOTSUP; + + if (op == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, op cannot be NULL\n", dev_id); + return -EINVAL; + } + + if (error == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, error cannot be NULL\n", dev_id); + return -EINVAL; + } +#else + dev = rte_ml_dev_pmd_get_dev(dev_id); +#endif + + return (*dev->op_error_get)(dev, op, error); +} + RTE_LOG_REGISTER_DEFAULT(rte_ml_dev_logtype, INFO); diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index bc94420000..14c33175d2 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -73,6 +73,25 @@ typedef uint16_t (*mldev_enqueue_t)(struct rte_ml_dev *dev, uint16_t qp_id, stru typedef uint16_t (*mldev_dequeue_t)(struct rte_ml_dev *dev, uint16_t qp_id, struct rte_ml_op **ops, uint16_t nb_ops); +/** + * @internal + * + * Get error information for an Op. + * + * @param dev + * ML device pointer. + * @param op + * ML Op handle. + * @param error + * Pointer to error structure. + * + * @return + * - 0 on success. + * - <0, error on failure. + */ +typedef int (*mldev_op_error_get_t)(struct rte_ml_dev *dev, struct rte_ml_op *op, + struct rte_ml_op_error *error); + /** * Definitions of all functions exported by a driver through the generic structure of type * *ml_dev_ops* supplied in the *rte_ml_dev* structure associated with a device. @@ -619,6 +638,9 @@ struct rte_ml_dev { /** Pointer to PMD dequeue function. */ mldev_dequeue_t dequeue_burst; + /** Pointer to PMD Op error get function. */ + mldev_op_error_get_t op_error_get; + /** Pointer to device data. */ struct rte_ml_dev_data *data; diff --git a/lib/mldev/version.map b/lib/mldev/version.map index 1e7c1ab2b2..ea91912f5f 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -30,6 +30,7 @@ EXPERIMENTAL { rte_ml_model_start; rte_ml_model_stop; rte_ml_model_unload; + rte_ml_op_error_get; rte_ml_op_pool_create; rte_ml_op_pool_free; From patchwork Tue Feb 7 15:13:16 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 123268 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 851E641C30; Tue, 7 Feb 2023 16:15:03 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 6CC6E42D3C; Tue, 7 Feb 2023 16:14:20 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id 72DBC42D51 for ; Tue, 7 Feb 2023 16:14:18 +0100 (CET) Received: from pps.filterd (m0045849.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 317EbMa9006803; Tue, 7 Feb 2023 07:14:17 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=JswvuHNyUsfOYe129C/b8h+qBlcNgoljaRm7TJLTzwc=; b=e4Jy5FdJfFummvn4jT7802NG7P6AU8AkVXP0eYpALlvHEeXAeL9s5WfqAQorHzNyFdzs C7Sp5xP+pN9zlzJwLjrbrown5KjLS1qODCzsbtp5S8DkJ2ude8JnICd744h/YTdAmFAk iEWgnCsyMJObojUWHvYtn7/dsWbfmlIjQ8RMQlYmFcE5G2SQWjFF/McGhsFhYWCvlY3h iwe74boTm3RfZ7TpbWDMyqb78z1HB+KifUX4B0a0qjYEwpZFYk//MtfDUD90dw830VQh xwpXT7nnx9P8jaEXf4pU+aKfPXV6I7c74DBvz8MGmPjbiE73NVhsfIU+t/6uJf1udG1J tQ== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3nkdyrsk5u-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Tue, 07 Feb 2023 07:14:17 -0800 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.42; Tue, 7 Feb 2023 07:14:15 -0800 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.42 via Frontend Transport; Tue, 7 Feb 2023 07:14:15 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id 63B5B3F7082; Tue, 7 Feb 2023 07:14:13 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v3 12/12] mldev: support to get debug info and test device Date: Tue, 7 Feb 2023 20:43:16 +0530 Message-ID: <20230207151316.835441-13-jerinj@marvell.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230207151316.835441-1-jerinj@marvell.com> References: <20230206202453.336280-1-jerinj@marvell.com> <20230207151316.835441-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: X2zM5urZjuWFb00yZ6EoZrp_sh7f2Am6 X-Proofpoint-GUID: X2zM5urZjuWFb00yZ6EoZrp_sh7f2Am6 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.930,Hydra:6.0.562,FMLib:17.11.122.1 definitions=2023-02-07_07,2023-02-06_03,2022-06-22_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Srikanth Yalavarthi Added functions for ML device debug APIs. The APIs are used to dump ML device debug information and to run selftest. Signed-off-by: Srikanth Yalavarthi Signed-off-by: Jerin Jacob --- lib/mldev/rte_mldev.c | 39 ++++++++++++++++++++++++++++++++++++++ lib/mldev/rte_mldev_core.h | 37 ++++++++++++++++++++++++++++++++++++ lib/mldev/version.map | 2 ++ 3 files changed, 78 insertions(+) diff --git a/lib/mldev/rte_mldev.c b/lib/mldev/rte_mldev.c index 9258f44466..eeddb8e874 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -527,6 +527,45 @@ rte_ml_dev_xstats_reset(int16_t dev_id, const uint16_t *stat_ids, uint16_t nb_id return (*dev->dev_ops->dev_xstats_reset)(dev, stat_ids, nb_ids); } +int +rte_ml_dev_dump(int16_t dev_id, FILE *fd) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->dev_dump == NULL) + return -ENOTSUP; + + if (fd == NULL) { + RTE_MLDEV_LOG(ERR, "Dev %d, file descriptor cannot be NULL\n", dev_id); + return -EINVAL; + } + + return (*dev->dev_ops->dev_dump)(dev, fd); +} + +int +rte_ml_dev_selftest(int16_t dev_id) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + RTE_MLDEV_LOG(ERR, "Invalid dev_id = %d\n", dev_id); + return -EINVAL; + } + + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (*dev->dev_ops->dev_selftest == NULL) + return -ENOTSUP; + + return (*dev->dev_ops->dev_selftest)(dev); +} + int rte_ml_model_load(int16_t dev_id, struct rte_ml_model_params *params, uint16_t *model_id) { diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index 14c33175d2..98851e0fd5 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -317,6 +317,37 @@ typedef int (*mldev_xstats_get_t)(struct rte_ml_dev *dev, const uint16_t *stat_i typedef int (*mldev_xstats_reset_t)(struct rte_ml_dev *dev, const uint16_t *stat_ids, uint16_t nb_ids); +/** + * @internal + * + * Function used to dump ML device debug info. + * + * @param dev + * ML device pointer. + * @param fd + * File descriptor to dump the debug info. + * + * @return + * - 0 on success. + * - < 0, error code on failure. + */ + +typedef int (*mldev_dump_t)(struct rte_ml_dev *dev, FILE *fd); + +/** + * @internal + * + * Function used for selftest of ML device. + * + * @param dev + * ML device pointer. + * + * @return + * - 0 on success. + * - < 0, error on failure. + */ +typedef int (*mldev_selftest_t)(struct rte_ml_dev *dev); + /** * @internal * @@ -560,6 +591,12 @@ struct rte_ml_dev_ops { /** Reset extended stats of the device. */ mldev_xstats_reset_t dev_xstats_reset; + /** Dump ML device debug info. */ + mldev_dump_t dev_dump; + + /** Dump ML device debug info. */ + mldev_selftest_t dev_selftest; + /** Load an ML model. */ mldev_model_load_t model_load; diff --git a/lib/mldev/version.map b/lib/mldev/version.map index ea91912f5f..d2b30a991a 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -5,11 +5,13 @@ EXPERIMENTAL { rte_ml_dev_close; rte_ml_dev_configure; rte_ml_dev_count; + rte_ml_dev_dump; rte_ml_dev_info_get; rte_ml_dev_init; rte_ml_dev_is_valid_dev; rte_ml_dev_logtype; rte_ml_dev_queue_pair_setup; + rte_ml_dev_selftest; rte_ml_dev_socket_id; rte_ml_dev_start; rte_ml_dev_stats_get;