From patchwork Mon Nov 14 12:02:27 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 119825 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 9D34FA00C4; Mon, 14 Nov 2022 13:07:05 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 2D3A142D23; Mon, 14 Nov 2022 13:06:58 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id 4406142C29 for ; Mon, 14 Nov 2022 13:06:56 +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 2AE7v5FM024488; Mon, 14 Nov 2022 04:03:40 -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=nRlr1iOiB21Cc6c2AE5GUWS6D/+nYSOF0v8tpKo5aWU=; b=GRfyJGE4dpuXp3ELTcrJvSoU20Rp9n1Vj3yRQxSsBVKg8xQOm3vVqOVDrY7I629Fa9X2 cEXPOBsEye85PuI7mMQWi30QhA3vCNXerN7cTNMhWvd78W4o5IAQ8g6KuhfGqETjUQhl HMktmRoE8V0Y/bqmDeKQR17qkiHqZjKltxwa6ZRXMvmHSXFeXyYbePkVoUUMCd3cM1Qj +N0TeTIGR9zrEbh4xq86CRjiwSb4OlIJXHYavDD8FeKaSTrLEzn0i+FKZDRrOIOuHCsA 4GuBUp8DqR1YSG9nL0URKC4ZEk9/dwh3TFn7E4uLc0OhsD4MQOUgwbDjDShst+AepifI 5g== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3kuhr3gn0x-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 14 Nov 2022 04:03:40 -0800 Received: from DC5-EXCH01.marvell.com (10.69.176.38) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Mon, 14 Nov 2022 04:03:38 -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.2 via Frontend Transport; Mon, 14 Nov 2022 04:03:38 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id F0C0D5C68F5; Mon, 14 Nov 2022 04:03:12 -0800 (PST) From: To: , Thomas Monjalon , Bruce Richardson , Srikanth Yalavarthi CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v1 01/12] mldev: introduce machine learning device library Date: Mon, 14 Nov 2022 17:32:27 +0530 Message-ID: <20221114120238.2143832-2-jerinj@marvell.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20221114120238.2143832-1-jerinj@marvell.com> References: <20220803132839.2747858-2-jerinj@marvell.com> <20221114120238.2143832-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: TGj3OF2365qfrI-LhJb1_CfsF_o1UOHR X-Proofpoint-ORIG-GUID: TGj3OF2365qfrI-LhJb1_CfsF_o1UOHR X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-11-14_10,2022-11-11_01,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 Signed-off-by: Jerin Jacob Signed-off-by: Srikanth Yalavarthi Acked-by: Shivah Shankar S Acked-by: Shivah Shankar S --- MAINTAINERS | 5 + config/rte_config.h | 3 + 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 ++++ lib/eal/common/eal_common_log.c | 1 + lib/eal/include/rte_log.h | 1 + lib/meson.build | 1 + lib/mldev/meson.build | 18 + lib/mldev/rte_mldev.c | 5 + lib/mldev/rte_mldev.h | 1092 ++++++++++++++++++++++ lib/mldev/version.map | 3 + 14 files changed, 2032 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 0e2fd39928..b2ab042248 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -534,6 +534,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/config/rte_config.h b/config/rte_config.h index 3c4876d434..083d37757d 100644 --- a/config/rte_config.h +++ b/config/rte_config.h @@ -83,6 +83,9 @@ /* rawdev defines */ #define RTE_RAWDEV_MAX_DEVS 64 +/* mldev defines */ +#define RTE_MLDEV_MAX_DEVS 64 + /* ip_fragmentation defines */ #define RTE_LIBRTE_IP_FRAG_MAX_FRAG 8 // RTE_LIBRTE_IP_FRAG_TBL_STAT is not set 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..9809f2dba3 --- /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(uint8_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/lib/eal/common/eal_common_log.c b/lib/eal/common/eal_common_log.c index bd7b188ceb..5cb1b15dbe 100644 --- a/lib/eal/common/eal_common_log.c +++ b/lib/eal/common/eal_common_log.c @@ -369,6 +369,7 @@ static const struct logtype logtype_strings[] = { {RTE_LOGTYPE_EFD, "lib.efd"}, {RTE_LOGTYPE_EVENTDEV, "lib.eventdev"}, {RTE_LOGTYPE_GSO, "lib.gso"}, + {RTE_LOGTYPE_MLDEV, "lib.mldev"}, {RTE_LOGTYPE_USER1, "user1"}, {RTE_LOGTYPE_USER2, "user2"}, {RTE_LOGTYPE_USER3, "user3"}, diff --git a/lib/eal/include/rte_log.h b/lib/eal/include/rte_log.h index bba5da3d85..df6fada0b1 100644 --- a/lib/eal/include/rte_log.h +++ b/lib/eal/include/rte_log.h @@ -48,6 +48,7 @@ extern "C" { #define RTE_LOGTYPE_EFD 18 /**< Log related to EFD. */ #define RTE_LOGTYPE_EVENTDEV 19 /**< Log related to eventdev. */ #define RTE_LOGTYPE_GSO 20 /**< Log related to GSO. */ +#define RTE_LOGTYPE_MLDEV 21 /**< Log related to mldev. */ /* these log types can be used in an application */ #define RTE_LOGTYPE_USER1 24 /**< User-defined log type 1. */ diff --git a/lib/meson.build b/lib/meson.build index fd55925340..f18b352ec5 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..2e3dfa0e6b --- /dev/null +++ b/lib/mldev/rte_mldev.c @@ -0,0 +1,5 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2022 Marvell. + */ + +#include diff --git a/lib/mldev/rte_mldev.h b/lib/mldev/rte_mldev.h new file mode 100644 index 0000000000..83419fcecd --- /dev/null +++ b/lib/mldev/rte_mldev.h @@ -0,0 +1,1092 @@ +/* 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_model_start() + * - rte_ml_model_info_get() + * - rte_ml_dev_start() + * - 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 + +#ifdef __cplusplus +extern "C" { +#endif + +#define RTE_ML_STR_MAX 128 +/**< Maximum length of name string */ + +/* Device operations */ + +/** + * 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 */ + int16_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. */ + int16_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 { + int16_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, int16_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, int16_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, int16_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, int16_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 */ + int16_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, int16_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, int16_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, int16_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, int16_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, int16_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, int16_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..33c1b976f1 --- /dev/null +++ b/lib/mldev/version.map @@ -0,0 +1,3 @@ +EXPERIMENTAL { + local: *; +}; From patchwork Mon Nov 14 12:02:28 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 119823 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 41A3AA00C4; Mon, 14 Nov 2022 13:06:56 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 34EB541148; Mon, 14 Nov 2022 13:06:56 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id C29994014F for ; Mon, 14 Nov 2022 13:06:54 +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 2AE7vUsB025131; Mon, 14 Nov 2022 04:04: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=yls8K4o/KP7ofRZ8v+NcryJTBfjsRkTdA8YOqCvBEVc=; b=J/FUd4wx+wlSnlZcqQ7ebSNNv0WJMRcDQksTQ3Jw5XncHmT61ezjghhP1+FkVtXb22Hs zR+v6meuPE3CzbIrSdd0PgWzXWqgK6Sg0HblgcuOydVCJfyrnV3mkqKiHfBf/gU3+V1L fGFkOOmTQ9ZANujdsWFLTZSSKrG6Xyy8iSQJRKz9Vtw0SKLbEYg7GNJ/lbzeBYMRZ8D6 9zS7ilafPmNtKlQtiYcbvJS/RUxHJmOp4uH1zGTw5fQOetfGCtAXNfcV/eC43olSTe+D begZDNH6ilfDBhxXPRDcmcwrdh+PF5XVnQtmO28mtjMxwvbABqlvpbQMmsZjc8JiuYhu 9g== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3kuhr3gn2j-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 14 Nov 2022 04:04:10 -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.18; Mon, 14 Nov 2022 04:04:08 -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.2 via Frontend Transport; Mon, 14 Nov 2022 04:04:08 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id 79D255C68E2; Mon, 14 Nov 2022 04:03:43 -0800 (PST) From: To: , Srikanth Yalavarthi , "Anatoly Burakov" CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v1 02/12] mldev: add PMD functions for ML device Date: Mon, 14 Nov 2022 17:32:28 +0530 Message-ID: <20221114120238.2143832-3-jerinj@marvell.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20221114120238.2143832-1-jerinj@marvell.com> References: <20220803132839.2747858-2-jerinj@marvell.com> <20221114120238.2143832-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: 1qKAYbSfPHblg5g0kt--tyHFPRXUnGtR X-Proofpoint-ORIG-GUID: 1qKAYbSfPHblg5g0kt--tyHFPRXUnGtR X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-11-14_10,2022-11-11_01,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. Signed-off-by: Srikanth Yalavarthi Signed-off-by: Jerin Jacob --- lib/mldev/meson.build | 9 +++ lib/mldev/rte_mldev.c | 128 +++++++++++++++++++++++++++++++ lib/mldev/rte_mldev_core.h | 115 ++++++++++++++++++++++++++++ lib/mldev/rte_mldev_pmd.c | 61 +++++++++++++++ lib/mldev/rte_mldev_pmd.h | 149 +++++++++++++++++++++++++++++++++++++ lib/mldev/version.map | 11 +++ 6 files changed, 473 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 2e3dfa0e6b..a4e0b5f94f 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -3,3 +3,131 @@ */ #include +#include + +static struct rte_ml_dev ml_devices[RTE_MLDEV_MAX_DEVS]; + +static struct rte_ml_dev_global ml_dev_globals = { + .devs = ml_devices, .data = {NULL}, .nb_devs = 0, .max_devs = RTE_MLDEV_MAX_DEVS}; + +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 < RTE_MLDEV_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; + + if (rte_ml_dev_pmd_get_named_dev(name) != NULL) { + ML_DEV_LOG(ERR, "ML device with name %s already allocated!", name); + return NULL; + } + + /* Get a free device ID */ + for (dev_id = 0; dev_id < RTE_MLDEV_MAX_DEVS; dev_id++) { + dev = rte_ml_dev_pmd_get_dev(dev_id); + if (dev->attached == ML_DEV_DETACHED) + break; + } + + if (dev_id == RTE_MLDEV_MAX_DEVS) { + ML_DEV_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); + ML_DEV_LOG(DEBUG, "PRIMARY: reserved memzone for %s (%p)", mz_name, mz); + } else { + mz = rte_memzone_lookup(mz_name); + ML_DEV_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; + ML_DEV_LOG(DEBUG, "PRIMARY: init mldev data"); + } + + ML_DEV_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) { + ML_DEV_LOG(DEBUG, "PRIMARY: free memzone of %s (%p)", mz_name, mz); + ret = rte_memzone_free(mz); + } else { + ML_DEV_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; +} diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h new file mode 100644 index 0000000000..b5cb69c5fb --- /dev/null +++ b/lib/mldev/rte_mldev_core.h @@ -0,0 +1,115 @@ +/* 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 + +/* Logging Macro */ +#define ML_DEV_LOG(level, fmt, args...) \ + rte_log(RTE_LOG_##level, RTE_LOGTYPE_MLDEV, "%s(): " fmt "\n", __func__, ##args) + +/* 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 { + /** Unique identifier name. */ + char name[RTE_ML_STR_MAX]; + + /** 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; + + /** Reserved for future fields */ + uint64_t reserved[3]; +} __rte_cache_aligned; + +/** + * @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[RTE_MLDEV_MAX_DEVS]; + + /** 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..796432f1f8 --- /dev/null +++ b/lib/mldev/rte_mldev_pmd.c @@ -0,0 +1,61 @@ +/* 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; + + ML_DEV_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) { + ML_DEV_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) { + ML_DEV_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; + + ML_DEV_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 33c1b976f1..82eedfada4 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -1,3 +1,14 @@ EXPERIMENTAL { 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 Mon Nov 14 12:02:29 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 119824 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 5642BA00C4; Mon, 14 Nov 2022 13:07:00 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 38D7342D1A; Mon, 14 Nov 2022 13:06: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 1F02D4014F for ; Mon, 14 Nov 2022 13:06:56 +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 2AE6h1dm008489; Mon, 14 Nov 2022 04:04:37 -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=Ix4V0fCZs0JuxpigVkb+12Xzjfxa8DNlNeAxrAsQ0Pc=; b=VYfi2lkaTvt/HCjL22mRVbXtmWhr5P35mEcDT39g119dHHgW/XxN+F2k019ihNU7aA3y YhljPdX5JDr/6H1dhI83m5PUALMpygYh+a0vWVkhSGT01Z+nml4Cac+t9PMcE2qflusm s3jvYCFkqWEBQEkVMQ34Oqik+NqdyblA3LgdSHxb7ROfj/d9ibpotSH/TqO47WAjx+k/ xf6ZKQpHMamrEmjc9uutepYChoI8NvoZ42Ofn/9pisJwEU6MeRK42uceEKpNvqYWVQZh bgm6JVj284HD9H0HwLnNwBMlbavn7bXxRi4DGt9z0L6g2UiVl8e2/zg6RyXnT0ZJZzwd 1A== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3kugnb0wry-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 14 Nov 2022 04:04:37 -0800 Received: from DC5-EXCH01.marvell.com (10.69.176.38) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Mon, 14 Nov 2022 04:04:35 -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.2 via Frontend Transport; Mon, 14 Nov 2022 04:04:34 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id 1E2495C68E2; Mon, 14 Nov 2022 04:04:09 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v1 03/12] mldev: support device handling functions Date: Mon, 14 Nov 2022 17:32:29 +0530 Message-ID: <20221114120238.2143832-4-jerinj@marvell.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20221114120238.2143832-1-jerinj@marvell.com> References: <20220803132839.2747858-2-jerinj@marvell.com> <20221114120238.2143832-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: fbUNtr5-GCUCzw8Va_rsjHF-JGJc0iXU X-Proofpoint-GUID: fbUNtr5-GCUCzw8Va_rsjHF-JGJc0iXU X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-11-14_10,2022-11-11_01,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 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 | 11 +++ 3 files changed, 293 insertions(+) diff --git a/lib/mldev/rte_mldev.c b/lib/mldev/rte_mldev.c index a4e0b5f94f..651f8b2f7c 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -131,3 +131,178 @@ rte_ml_dev_pmd_release(struct rte_ml_dev *dev) return ret; } + +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_devices[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)) { + ML_DEV_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)) { + ML_DEV_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) { + ML_DEV_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)) { + ML_DEV_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) { + ML_DEV_LOG(ERR, "Device %d must be stopped to allow configuration", dev_id); + return -EBUSY; + } + + if (config == NULL) { + ML_DEV_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) { + ML_DEV_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)) { + ML_DEV_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) { + ML_DEV_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)) { + ML_DEV_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) { + ML_DEV_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)) { + ML_DEV_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) { + ML_DEV_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; +} diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index b5cb69c5fb..1405cce7f7 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -35,6 +35,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 * @@ -82,6 +186,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 82eedfada4..1be508ab5f 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -1,4 +1,15 @@ EXPERIMENTAL { + global: + + rte_ml_dev_close; + rte_ml_dev_configure; + rte_ml_dev_count; + rte_ml_dev_info_get; + rte_ml_dev_is_valid_dev; + rte_ml_dev_socket_id; + rte_ml_dev_start; + rte_ml_dev_stop; + local: *; }; From patchwork Mon Nov 14 12:02:30 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 119826 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 7985BA00C4; Mon, 14 Nov 2022 13:07:27 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 6873242C29; Mon, 14 Nov 2022 13:07:27 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id A08D542C29 for ; Mon, 14 Nov 2022 13:07:25 +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 2AE6h5OC008532; Mon, 14 Nov 2022 04:05: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=Vp26mkqtBcpq1xhaIvt9jFoMF0fXCPchxamtym9jhMo=; b=g/R5uoYukDcQT+8af1H5gt4X+w852ib4PLOH3rlwNdD1IaK0Qa3KUrr730hfKNxUdJsm qcjpthlONEONDkMCAcfV+nK1oVFSmnzfgKgd3Ixgs50vs3vGkbrAkjm4V9+eMPavV528 o+6hYHBfIa6sQFOaCI58tIAQa0iL46QPF9tdrAi5OEqChCtrNOrc/dgdZbVnD8wy2LjN +XV5mzluTGQmjlA3cNsu6FKqaS8TWatn/kHhH0lKMHqjfdPFIxkc5E8Fp6DZBOBJnqcT pYNU9Z+td14p5Fi/Bu/M/8lct8MpUMkj/HjTslD6j61LHnASmXre+BKY1/BzainTHkLW Ng== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3kugnb0wsn-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 14 Nov 2022 04:05:02 -0800 Received: from DC5-EXCH01.marvell.com (10.69.176.38) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Mon, 14 Nov 2022 04:05:00 -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.2 via Frontend Transport; Mon, 14 Nov 2022 04:05:00 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id 8767C5C68E5; Mon, 14 Nov 2022 04:04:35 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v1 04/12] mldev: support device queue-pair setup Date: Mon, 14 Nov 2022 17:32:30 +0530 Message-ID: <20221114120238.2143832-5-jerinj@marvell.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20221114120238.2143832-1-jerinj@marvell.com> References: <20220803132839.2747858-2-jerinj@marvell.com> <20221114120238.2143832-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: lngkZEJddPk4tlgAqT8Alj28HZ5JdUbh X-Proofpoint-GUID: lngkZEJddPk4tlgAqT8Alj28HZ5JdUbh X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-11-14_10,2022-11-11_01,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 651f8b2f7c..c8672cff8e 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -306,3 +306,36 @@ 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)) { + ML_DEV_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) { + ML_DEV_LOG(ERR, "Invalid queue_pair_id = %d", queue_pair_id); + return -EINVAL; + } + + if (qp_conf == NULL) { + ML_DEV_LOG(ERR, "Dev %d, qp_conf cannot be NULL\n", dev_id); + return -EINVAL; + } + + if (dev->data->dev_started) { + ML_DEV_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); +} diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index 1405cce7f7..e2a16034d6 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -117,6 +117,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 * @@ -137,6 +175,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 1be508ab5f..cd44c05f3a 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -6,6 +6,7 @@ EXPERIMENTAL { rte_ml_dev_count; rte_ml_dev_info_get; rte_ml_dev_is_valid_dev; + rte_ml_dev_queue_pair_setup; rte_ml_dev_socket_id; rte_ml_dev_start; rte_ml_dev_stop; From patchwork Mon Nov 14 12:02:31 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 119827 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 A3957A00C4; Mon, 14 Nov 2022 13:08:16 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 91E9940150; Mon, 14 Nov 2022 13:08: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 BB71D4014F for ; Mon, 14 Nov 2022 13:08: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 2AE7v5FX024488; Mon, 14 Nov 2022 04:05:27 -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=Q6DiOefvbajoO0aKtP+WNDlBuQr/3EMi7lpu86kkVr4=; b=b0t+tOPKaS2a7/y9N2diUJi07gQW3ejV8R3/Gz39F+L9El/1L/uCVPbpBxsv1tWbW5Dl cqrhLfcHD6fn06RV2b4J+h9u8/GS4f8LYa58rPHpOWU26/MVT0v7LoAFgLOjYgcOgFum tnJbzxi5IOi8hajcvlter3AQlPibWck+jA6H7pR+8yYoW/Ilh+Vb62W8crywk4eIVjoM cZFzl9fSU0/TTC6gUMqgYl393hVk2qrMIs9tLSoTbVTvi3eCWJmggjQrIs8f3G3c/Pba EaVoxK/PGeNoTNRhxaLwECciSusJg6JCRQwLZY/JTp6jRhQX8BJp/qEYqI6bykZlRDgW ow== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3kuhr3gn5j-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 14 Nov 2022 04:05:27 -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.18; Mon, 14 Nov 2022 04:05:25 -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.18 via Frontend Transport; Mon, 14 Nov 2022 04:05:25 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id EAD1A5C68E2; Mon, 14 Nov 2022 04:05:00 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v1 05/12] mldev: support handling ML models Date: Mon, 14 Nov 2022 17:32:31 +0530 Message-ID: <20221114120238.2143832-6-jerinj@marvell.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20221114120238.2143832-1-jerinj@marvell.com> References: <20220803132839.2747858-2-jerinj@marvell.com> <20221114120238.2143832-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: 4aCDmd0pYczB3EZx8Jh1Rl1PVEGaOwQt X-Proofpoint-ORIG-GUID: 4aCDmd0pYczB3EZx8Jh1Rl1PVEGaOwQt X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-11-14_10,2022-11-11_01,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 c8672cff8e..327ed7144d 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -339,3 +339,126 @@ 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, int16_t *model_id) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + ML_DEV_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) { + ML_DEV_LOG(ERR, "Dev %d, params cannot be NULL\n", dev_id); + return -EINVAL; + } + + if (model_id == NULL) { + ML_DEV_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, int16_t model_id) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + ML_DEV_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, int16_t model_id) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + ML_DEV_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, int16_t model_id) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + ML_DEV_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, int16_t model_id, struct rte_ml_model_info *model_info) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + ML_DEV_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) { + ML_DEV_LOG(ERR, "Dev %d, model_id %d, 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, int16_t model_id, void *buffer) +{ + struct rte_ml_dev *dev; + + if (!rte_ml_dev_is_valid_dev(dev_id)) { + ML_DEV_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) { + ML_DEV_LOG(ERR, "Dev %d, buffer cannot be NULL\n", dev_id); + return -EINVAL; + } + + return (*dev->dev_ops->model_params_update)(dev, model_id, buffer); +} diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index e2a16034d6..172454c2aa 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -155,6 +155,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, + int16_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, int16_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, int16_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, int16_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, int16_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, int16_t model_id, void *buffer); + /** * @internal * @@ -181,6 +285,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 cd44c05f3a..4459f02925 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -10,6 +10,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 Mon Nov 14 12:02:32 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 119828 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 14225A00C4; Mon, 14 Nov 2022 13:08:20 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 8341F42C29; Mon, 14 Nov 2022 13:08:19 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 17F9B42C29 for ; Mon, 14 Nov 2022 13:08:17 +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 2AE6hJAg008852; Mon, 14 Nov 2022 04:05:53 -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=NLlbwHmrW2i3Ymqu0ltU8fOPv5T2d+s5wwdLa/WaklU=; b=BUGH0tZLXP8l0w6INszFFyInlVeZUvV9KFoFLf4XpKX51Kp71yKXhLmrotqVYZdhqJ0i LtDyPRV2V+rA2jptj7/UxAY8u3r8Xg3IRSXL0+LaARImgBvA8TYd7hktvTjvOhU+yjDp I8D6xlm/gI1aBfXqy36iz3z+S6mQ3g+UDM1u5Jg+vhRw9iFToSESxF09EHyABw754UsX 9SGNXu9a/hN5J/bQ7DDqRQxaMzqWHpzBAqTflBrPqnkqCEl+oWkoVIVUOomcnbsi0IBr QUE+kKQz37ZAXpNUtifwh1p3MxvGOYEBJOyZ1pNVtXoOzX70KlJZHFy9BoDUW4msSpTL eA== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3kugnb0wuh-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 14 Nov 2022 04:05:53 -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.18; Mon, 14 Nov 2022 04:05:51 -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.2 via Frontend Transport; Mon, 14 Nov 2022 04:05:51 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id 5E0BE5C68E6; Mon, 14 Nov 2022 04:05:26 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v1 06/12] mldev: support input and output data handling Date: Mon, 14 Nov 2022 17:32:32 +0530 Message-ID: <20221114120238.2143832-7-jerinj@marvell.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20221114120238.2143832-1-jerinj@marvell.com> References: <20220803132839.2747858-2-jerinj@marvell.com> <20221114120238.2143832-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: so50KI0ZvCEpwdGb5yZTCSygYkDwFV3Z X-Proofpoint-GUID: so50KI0ZvCEpwdGb5yZTCSygYkDwFV3Z X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-11-14_10,2022-11-11_01,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 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 327ed7144d..13b7e93943 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -462,3 +462,97 @@ rte_ml_model_params_update(int16_t dev_id, int16_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, int16_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)) { + ML_DEV_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, int16_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)) { + ML_DEV_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, int16_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)) { + ML_DEV_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) { + ML_DEV_LOG(ERR, "Dev %d, dbuffer cannot be NULL\n", dev_id); + return -EINVAL; + } + + if (qbuffer == NULL) { + ML_DEV_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, int16_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)) { + ML_DEV_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) { + ML_DEV_LOG(ERR, "Dev %d, qbuffer cannot be NULL\n", dev_id); + return -EINVAL; + } + + if (dbuffer == NULL) { + ML_DEV_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); +} diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index 172454c2aa..b388553a96 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -259,6 +259,100 @@ typedef int (*mldev_model_info_get_t)(struct rte_ml_dev *dev, int16_t model_id, */ typedef int (*mldev_model_params_update_t)(struct rte_ml_dev *dev, int16_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, int16_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, int16_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, int16_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, int16_t model_id, uint16_t nb_batches, + void *qbuffer, void *dbuffer); + /** * @internal * @@ -303,6 +397,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 4459f02925..0b180020db 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -10,6 +10,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 Mon Nov 14 12:02:33 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 119829 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 48C09A00C4; Mon, 14 Nov 2022 13:08:51 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 3B04D42D11; Mon, 14 Nov 2022 13:08:51 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id D1B954014F for ; Mon, 14 Nov 2022 13:08:49 +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 2AE7vM8t024855; Mon, 14 Nov 2022 04:06:20 -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=m4jkJrIR0m5L3OpqKGj6z2hSNbgtAt0XY6PtzDH+WBk=; b=KoO38Yh9m3fTJPPXtIunr7RNESx3r/bVfB3YaAXAO7ONhrnlFt7vKyrw2GIDiY+6LKUA AXl185RGeT1bvKNdqaFaviG+rER63jP8Gwqd2YLO5/8iFUNLwtMRi81tAXOpk/C6gLXs 3in94sgbRsnuysnlg7ARE/1bX0FEwSl18O3uLU7Bjl4vIBsWA4/QcvAh4+DZy/fnEwZ3 QC/bArBYutbWD/6XX3K94ekLQBnZ8LFbCpb9S6iMa77UgfCfbsS7VsDAf0uPBDoqzH4r iRQc4bwg+tA1H3bfAtb9JUhp58hzwGhnUrIyVjyYV3fa4Ml70g/31/tdkgn9QMihkWqF 1Q== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3kuhr3gn7c-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 14 Nov 2022 04:06:19 -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.18; Mon, 14 Nov 2022 04:06:17 -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.18 via Frontend Transport; Mon, 14 Nov 2022 04:06:17 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id BFCD45C68E5; Mon, 14 Nov 2022 04:05:51 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v1 07/12] mldev: support op pool and its operations Date: Mon, 14 Nov 2022 17:32:33 +0530 Message-ID: <20221114120238.2143832-8-jerinj@marvell.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20221114120238.2143832-1-jerinj@marvell.com> References: <20220803132839.2747858-2-jerinj@marvell.com> <20221114120238.2143832-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: XHmwuSi0HFq0wf6HcpldsspikILVDvJ7 X-Proofpoint-ORIG-GUID: XHmwuSi0HFq0wf6HcpldsspikILVDvJ7 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-11-14_10,2022-11-11_01,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 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 13b7e93943..cc87837d85 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -10,6 +10,17 @@ static struct rte_ml_dev ml_devices[RTE_MLDEV_MAX_DEVS]; static struct rte_ml_dev_global ml_dev_globals = { .devs = ml_devices, .data = {NULL}, .nb_devs = 0, .max_devs = RTE_MLDEV_MAX_DEVS}; +/* + * 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) { @@ -556,3 +567,61 @@ rte_ml_io_dequantize(int16_t dev_id, int16_t model_id, uint16_t nb_batches, void 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; + ML_DEV_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) { + ML_DEV_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); +} diff --git a/lib/mldev/version.map b/lib/mldev/version.map index 0b180020db..396ca0b96a 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -20,6 +20,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 Mon Nov 14 12:02:34 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 119830 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 D4E02A00C4; Mon, 14 Nov 2022 13:09:07 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id C4A9340150; Mon, 14 Nov 2022 13:09:07 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 5C1604014F for ; Mon, 14 Nov 2022 13:09:06 +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 2AE6h1B5008496; Mon, 14 Nov 2022 04:06:45 -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=mTuuWXmirBa9P5VE17mJlqq2CXWTe8vlIvwA3yPo5D0=; b=MrcVTqNJvgkzkxPw+vCYvQTEjww1/Wl8mZEtq1nwwueU2kYy5N14383k6RGcXFx7tXVN m2lHJ0jyYMrqQF+dD+grst+wcYKJWLtS172/fBowF/Jx8DfHwf8i8VPhedPQtBRyWB3I vKJZdUwsN2rp9SbMyQhARIgV5lKUVwmYHMrO78f6K0gD76VDXAyMxUQfSnqg82U0Z8uo AqtUKp0h/OYAShiz1QKmAU3vxwA5M/bQdUsEehzLVIDGRKuoUb5d+X8gaN6Y7wdBL2iQ UXsjm7CJWjJBmUdftyYA362p0akTBYg6B7G1ErPLf0kMHNfvNqnXMhp6H/mneYHFwKt3 SA== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3kugnb0wwu-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 14 Nov 2022 04:06:44 -0800 Received: from DC5-EXCH01.marvell.com (10.69.176.38) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Mon, 14 Nov 2022 04:06:42 -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.2 via Frontend Transport; Mon, 14 Nov 2022 04:06:42 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id 407D15C6928; Mon, 14 Nov 2022 04:06:17 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v1 08/12] mldev: support inference enqueue and dequeue Date: Mon, 14 Nov 2022 17:32:34 +0530 Message-ID: <20221114120238.2143832-9-jerinj@marvell.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20221114120238.2143832-1-jerinj@marvell.com> References: <20220803132839.2747858-2-jerinj@marvell.com> <20221114120238.2143832-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: W_CMHeuSw4YrqIPQ3MHCz1U4s-9bdz5A X-Proofpoint-GUID: W_CMHeuSw4YrqIPQ3MHCz1U4s-9bdz5A X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-11-14_10,2022-11-11_01,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 | 76 ++++++++++++++++++++++++++++++++++++++ lib/mldev/rte_mldev_core.h | 46 +++++++++++++++++++++++ lib/mldev/rte_mldev_pmd.h | 2 + lib/mldev/version.map | 2 + 4 files changed, 126 insertions(+) diff --git a/lib/mldev/rte_mldev.c b/lib/mldev/rte_mldev.c index cc87837d85..adf8ab8cbc 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -2,6 +2,7 @@ * Copyright (c) 2022 Marvell. */ +#include #include #include @@ -105,6 +106,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; } @@ -625,3 +629,75 @@ rte_ml_op_pool_free(struct rte_mempool *mempool) if (mempool != NULL) 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)) { + ML_DEV_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) { + ML_DEV_LOG(ERR, "Dev %d, ops cannot be NULL\n", dev_id); + rte_errno = -EINVAL; + return 0; + } + + if (qp_id >= dev->data->nb_queue_pairs) { + ML_DEV_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)) { + ML_DEV_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) { + ML_DEV_LOG(ERR, "Dev %d, ops cannot be NULL\n", dev_id); + rte_errno = -EINVAL; + return 0; + } + + if (qp_id >= dev->data->nb_queue_pairs) { + ML_DEV_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); +} diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index b388553a96..9c19d7badf 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -37,6 +37,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. @@ -455,6 +495,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 396ca0b96a..5d44d210d7 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; @@ -10,6 +11,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 Mon Nov 14 12:02:35 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 119831 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 50631A034C; Mon, 14 Nov 2022 13:09:45 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 42F7E410E5; Mon, 14 Nov 2022 13:09:45 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 2729140DFD for ; Mon, 14 Nov 2022 13:09:43 +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 2AE6hJAp008852; Mon, 14 Nov 2022 04:07: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=VBIwRTC9V/2olikzRH22/iGcadLaH6VQ8+RIzHTguL4=; b=PqcnG6+bcfzBwXo6ZH48PL6AZE6WqQnSKqUXzVeL6jGe4+h38iZCUvrVv8tRiVI2RciV u/wLmA02QJxqvzzurEHqzpUIQxPEBGxuiU57YazbQ+Y6lTLl4lIpjgvvrGw22zTTA8To HLNT1ZK6Bz3KjkwplaNsdlmuCyFVsvrMM/dPhT3ZoPWUW0mQfBKgW3EJ6pNqCbjHnhix eXqn6WJdvVTu3c7yssi6A7QCAX17n6WD7vjShUPm7qs55pe9DuMzSwnNsEx/A4c4sWe7 b4d8yXuwymKOsjNyhoYqFiy3r+NmHVCSMsDGFyAvt6NlhGwlZOGNFtx6sPbTJS30AOFT cQ== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3kugnb0wyd-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 14 Nov 2022 04:07:10 -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.18; Mon, 14 Nov 2022 04:07: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.18 via Frontend Transport; Mon, 14 Nov 2022 04:07:08 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id 08F655C68E2; Mon, 14 Nov 2022 04:06:42 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v1 09/12] mldev: support device statistics Date: Mon, 14 Nov 2022 17:32:35 +0530 Message-ID: <20221114120238.2143832-10-jerinj@marvell.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20221114120238.2143832-1-jerinj@marvell.com> References: <20220803132839.2747858-2-jerinj@marvell.com> <20221114120238.2143832-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: 0RyeMM3djZw_AnpaAOMxJxINNB2634Yo X-Proofpoint-GUID: 0RyeMM3djZw_AnpaAOMxJxINNB2634Yo X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-11-14_10,2022-11-11_01,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 adf8ab8cbc..41b2a0be84 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -355,6 +355,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)) { + ML_DEV_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) { + ML_DEV_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)) { + ML_DEV_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, int16_t *model_id) { diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index 9c19d7badf..3f05ecd9c6 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -195,6 +195,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 * @@ -420,6 +446,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 5d44d210d7..d12263010b 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -10,6 +10,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 Mon Nov 14 12:02:36 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 119832 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 56029A00C4; Mon, 14 Nov 2022 13:09:56 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 3FE7541101; Mon, 14 Nov 2022 13:09:56 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 5C29840150 for ; Mon, 14 Nov 2022 13:09:54 +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 2AE6hJAw008852; Mon, 14 Nov 2022 04:07: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=YebgTGJePHS1jk8jLLtilR/+eIuTbZf77n+JieZxy04=; b=KyMtCDyFuLxvey7v9q6EfUH+lMf8HkTX2KdfGx9xKsS4IUYDQnHVoEtyJd1fQVGAKsZ5 gF/VkAVgbFaXhT2SPg7iL95YrGZpz1m/ypuRx7TE4wwoHd2PgcRG7013bjpBBlsyGzuv JxlLLgi+DrClc0T1X+ZZNt3a2ySdnR1mEIFxb0Wlz9LlvkKr7DDudfmbm58yRVPNe1Pt oAtPymd3ys+OH6mmm8Lf/83Zz5pr/m8wXS4DP2wUiNHD4kv/lHmKa3HxEec9b1Q+pFwB X4DcQA55wcuSOMCltogDvea1bYCXFM+2rOEPpSCChYBqq7mHfh2VTwMpC8kT1FE34KMK KA== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3kugnb0x1j-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 14 Nov 2022 04:07:36 -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.18; Mon, 14 Nov 2022 04:07: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.18 via Frontend Transport; Mon, 14 Nov 2022 04:07:33 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id 700EA5C68E6; Mon, 14 Nov 2022 04:07:08 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v1 10/12] mldev: support device extended statistics Date: Mon, 14 Nov 2022 17:32:36 +0530 Message-ID: <20221114120238.2143832-11-jerinj@marvell.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20221114120238.2143832-1-jerinj@marvell.com> References: <20220803132839.2747858-2-jerinj@marvell.com> <20221114120238.2143832-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: SLRMGjs9EGc-yBsxT1-NlO_o-QeqADbv X-Proofpoint-GUID: SLRMGjs9EGc-yBsxT1-NlO_o-QeqADbv X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-11-14_10,2022-11-11_01,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 41b2a0be84..cdd68e933c 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -395,6 +395,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)) { + ML_DEV_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)) { + ML_DEV_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) { + ML_DEV_LOG(ERR, "Dev %d, name cannot be NULL\n", dev_id); + return -EINVAL; + } + + if (value == NULL) { + ML_DEV_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)) { + ML_DEV_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) { + ML_DEV_LOG(ERR, "Dev %d, stat_ids cannot be NULL\n", dev_id); + return -EINVAL; + } + + if (values == NULL) { + ML_DEV_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)) { + ML_DEV_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, int16_t *model_id) { diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index 3f05ecd9c6..82e8ed0422 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -221,6 +221,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 * @@ -452,6 +533,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 d12263010b..02d2eab100 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -13,6 +13,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 Mon Nov 14 12:02:37 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 119833 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 01D62A00C4; Mon, 14 Nov 2022 13:10:37 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id E5CCD40150; Mon, 14 Nov 2022 13:10:36 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id 41B164014F for ; Mon, 14 Nov 2022 13:10:35 +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 2AE7vH2Y024571; Mon, 14 Nov 2022 04:08:01 -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=eBuLX8VlXXR9dL1Sfj08h468fJydnpfSa1stRE2oosE=; b=JSnP1LHxN+bPhVKTQQQJYNIA8yj6Bn8oTx4/GAp6CrsqhJz+NBLuDUOBl9zskCpTnpy2 F3HFZdl+J47Z68iW6WbU/NXzgwwJ3YHAmc0Agt7rYXQRws7ITZdiNtvEvq0ys6j7Hp/K M+HrU/zNpaCCJjZNJ9s2UWkKhnLGTgVfF5Q/5jj5pppDBQjIxMYKUxRVL7tJTUYvEsiZ 2uag82ba8fArNW9l3tZSFwFcvVAZwp2lFYnMB/s0aIrXVuuU1wI37DAqhhWRzquv7Ox9 IAHBzI7IuU8eJUaOs7Cf1gvbvVtovysVwiBxv1o5C4ez058imgVJiweTdGayzoZTNdNA pA== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3kuhr3gnf8-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 14 Nov 2022 04:08:00 -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.18; Mon, 14 Nov 2022 04:07:59 -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.18 via Frontend Transport; Mon, 14 Nov 2022 04:07:59 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id E82F85C68EC; Mon, 14 Nov 2022 04:07:33 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v1 11/12] mldev: support to retrieve error information Date: Mon, 14 Nov 2022 17:32:37 +0530 Message-ID: <20221114120238.2143832-12-jerinj@marvell.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20221114120238.2143832-1-jerinj@marvell.com> References: <20220803132839.2747858-2-jerinj@marvell.com> <20221114120238.2143832-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: OAfqq-HhPPmoQb2vXJzku-rv0LWfojfN X-Proofpoint-ORIG-GUID: OAfqq-HhPPmoQb2vXJzku-rv0LWfojfN X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-11-14_10,2022-11-11_01,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 cdd68e933c..7497a1316d 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -829,3 +829,34 @@ 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)) { + ML_DEV_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) { + ML_DEV_LOG(ERR, "Dev %d, op cannot be NULL\n", dev_id); + return -EINVAL; + } + + if (error == NULL) { + ML_DEV_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); +} diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index 82e8ed0422..9e3873dd3a 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -77,6 +77,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. @@ -626,6 +645,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 02d2eab100..86ab2129ce 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -28,6 +28,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 Mon Nov 14 12:02:38 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob Kollanukkaran X-Patchwork-Id: 119834 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 1C4A3A00C4; Mon, 14 Nov 2022 13:10:54 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 09FE742C29; Mon, 14 Nov 2022 13:10:54 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 59EFD4014F for ; Mon, 14 Nov 2022 13:10:52 +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 2AE6h37U008514; Mon, 14 Nov 2022 04:08:26 -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=fMM+6xRRJl8KFG3CmZMvaR0SIUGZxsv86SWPy+ztnlM=; b=Vey9zMjOPYMv77kyyZfqwGovpB/LiotS633Vw7uT76ChyLpzYo8iuCfByXSrjiDs1epP Bc9PGdOMfqv1i2HbFyL8bG6YhQTCsYiE7IaKj+7VbKqDuyGLiwpH12x0CrtYoCKMO5pw AV3W8sGXfhERsSFJU0gbNP7cu0NCKDuQGkZwNRnPi1qZtnse0h/H9+EI8LGg9NdjEhXT w3/K148EtgkWHHtWmtA/9grcui/BO6Z2sOPH+QY1TfPZNsfXlf9idRMhXRWhglecSGJW HNKe7zTNxzDl7zkOnW9PXpBsIqIA1t9/4up2lFKttzveFQmNN8Gor6sZnq4xmESShDkV iA== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3kugnb0x49-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Mon, 14 Nov 2022 04:08:26 -0800 Received: from DC5-EXCH01.marvell.com (10.69.176.38) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Mon, 14 Nov 2022 04:08:24 -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.2 via Frontend Transport; Mon, 14 Nov 2022 04:08:24 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id 5E1535C68E2; Mon, 14 Nov 2022 04:07:59 -0800 (PST) From: To: , Srikanth Yalavarthi CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v1 12/12] mldev: support to get debug info and test device Date: Mon, 14 Nov 2022 17:32:38 +0530 Message-ID: <20221114120238.2143832-13-jerinj@marvell.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20221114120238.2143832-1-jerinj@marvell.com> References: <20220803132839.2747858-2-jerinj@marvell.com> <20221114120238.2143832-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: IZgxTVJBupfAejTgp20t0Xi5J1UhADgk X-Proofpoint-GUID: IZgxTVJBupfAejTgp20t0Xi5J1UhADgk X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.895,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-11-14_10,2022-11-11_01,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 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 7497a1316d..71aa98ee96 100644 --- a/lib/mldev/rte_mldev.c +++ b/lib/mldev/rte_mldev.c @@ -483,6 +483,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)) { + ML_DEV_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) { + ML_DEV_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)) { + ML_DEV_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, int16_t *model_id) { diff --git a/lib/mldev/rte_mldev_core.h b/lib/mldev/rte_mldev_core.h index 9e3873dd3a..b1426806a3 100644 --- a/lib/mldev/rte_mldev_core.h +++ b/lib/mldev/rte_mldev_core.h @@ -321,6 +321,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 * @@ -564,6 +595,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 86ab2129ce..61955ab701 100644 --- a/lib/mldev/version.map +++ b/lib/mldev/version.map @@ -5,9 +5,11 @@ 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_is_valid_dev; rte_ml_dev_queue_pair_setup; + rte_ml_dev_selftest; rte_ml_dev_socket_id; rte_ml_dev_start; rte_ml_dev_stats_get;