From patchwork Sun Jan 7 15:34:42 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Srikanth Yalavarthi X-Patchwork-Id: 135781 X-Patchwork-Delegate: jerinj@marvell.com 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 2882143857; Sun, 7 Jan 2024 16:35:36 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 73CDE406A2; Sun, 7 Jan 2024 16:35:22 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id 7833C4067D for ; Sun, 7 Jan 2024 16:35:19 +0100 (CET) Received: from pps.filterd (m0045849.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.17.1.24/8.17.1.24) with ESMTP id 407EEcgF028095 for ; Sun, 7 Jan 2024 07:35:18 -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=9Nu8idqJXzreqNqfo7wu7ckcIISRinfrxGSMuBqqHUo=; b=NpA JM+EM5ZmJOp6nuNo5dEiUhNuFhyT2YeDnyLHuSMHyXLljU6EPqm92ZJfrbDHtZPo +b2FdsKlFrc51/ZuNweDk4gqJHI7g/TPhxcBhDiQKH3vpaaUtLuSR0SAsAVn99PH eOLuF9cgSCHkzZ2MEgVpd044Yjx1MC4ChXkjhIUEGCk5pBREK0CFswAYsVV4iUTe kk20BTuUJUq9b0WnweeEKYPnwbBz485dIBCHiPVNwWIjJWHjZKzY7nnXiPGwSqPw YAXz6scFBIb3BaBT63hd8sv7BKJQsMVZ9/RNdusShWWyA/Sjo7rBNCnnpRumCfaG DvTqFKJy9h7d6mogndQ== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3vf53qjk9y-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT) for ; Sun, 07 Jan 2024 07:35:18 -0800 (PST) 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.48; Sun, 7 Jan 2024 07:35:16 -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.48 via Frontend Transport; Sun, 7 Jan 2024 07:35:16 -0800 Received: from ml-host-33.caveonetworks.com (unknown [10.110.143.233]) by maili.marvell.com (Postfix) with ESMTP id 7F5223F70A5; Sun, 7 Jan 2024 07:35:16 -0800 (PST) From: Srikanth Yalavarthi To: Srikanth Yalavarthi , Jerin Jacob CC: , , , Subject: [PATCH 03/11] event/ml: add adapter create and free Date: Sun, 7 Jan 2024 07:34:42 -0800 Message-ID: <20240107153454.3909-4-syalavarthi@marvell.com> X-Mailer: git-send-email 2.42.0 In-Reply-To: <20240107153454.3909-1-syalavarthi@marvell.com> References: <20240107153454.3909-1-syalavarthi@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: KumB0faLdAXFg1Sk0_UU8t2I0coukGf7 X-Proofpoint-GUID: KumB0faLdAXFg1Sk0_UU8t2I0coukGf7 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.272,Aquarius:18.0.997,Hydra:6.0.619,FMLib:17.11.176.26 definitions=2023-12-09_02,2023-12-07_01,2023-05-22_02 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 Added ML event adapter create and free functions. Signed-off-by: Srikanth Yalavarthi --- lib/eventdev/rte_event_ml_adapter.c | 317 ++++++++++++++++++++++++++++ 1 file changed, 317 insertions(+) diff --git a/lib/eventdev/rte_event_ml_adapter.c b/lib/eventdev/rte_event_ml_adapter.c index 5b8b02a0130..fed3b67c858 100644 --- a/lib/eventdev/rte_event_ml_adapter.c +++ b/lib/eventdev/rte_event_ml_adapter.c @@ -4,3 +4,320 @@ #include "rte_event_ml_adapter.h" #include "rte_eventdev.h" +#include + +#include "eventdev_pmd.h" +#include "rte_mldev_pmd.h" + +#define ML_ADAPTER_NAME_LEN 32 +#define ML_DEFAULT_MAX_NB 128 +#define ML_ADAPTER_BUFFER_SIZE 1024 + +#define ML_ADAPTER_ARRAY "event_ml_adapter_array" + +/* ML ops circular buffer */ +struct ml_ops_circular_buffer { + /* Index of head element */ + uint16_t head; + + /* Index of tail element */ + uint16_t tail; + + /* Number of elements in buffer */ + uint16_t count; + + /* Size of circular buffer */ + uint16_t size; + + /* Pointer to hold rte_ml_op for processing */ + struct rte_ml_op **op_buffer; +} __rte_cache_aligned; + +/* ML device information */ +struct ml_device_info { + /* Pointer to mldev */ + struct rte_ml_dev *dev; +} __rte_cache_aligned; + +struct event_ml_adapter { + /* Event device identifier */ + uint8_t eventdev_id; + + /* Event port identifier */ + uint8_t event_port_id; + + /* Adapter mode */ + enum rte_event_ml_adapter_mode mode; + + /* Memory allocation name */ + char mem_name[ML_ADAPTER_NAME_LEN]; + + /* Socket identifier cached from eventdev */ + int socket_id; + + /* Lock to serialize config updates with service function */ + rte_spinlock_t lock; + + /* ML device structure array */ + struct ml_device_info *mldevs; + + /* Circular buffer for processing ML ops to eventdev */ + struct ml_ops_circular_buffer ebuf; + + /* Configuration callback for rte_service configuration */ + rte_event_ml_adapter_conf_cb conf_cb; + + /* Configuration callback argument */ + void *conf_arg; + + /* Set if default_cb is being used */ + int default_cb_arg; +} __rte_cache_aligned; + +static struct event_ml_adapter **event_ml_adapter; + +static inline int +emla_valid_id(uint8_t id) +{ + return id < RTE_EVENT_ML_ADAPTER_MAX_INSTANCE; +} + +static inline struct event_ml_adapter * +emla_id_to_adapter(uint8_t id) +{ + return event_ml_adapter ? event_ml_adapter[id] : NULL; +} + +static int +emla_array_init(void) +{ + const struct rte_memzone *mz; + uint32_t sz; + + mz = rte_memzone_lookup(ML_ADAPTER_ARRAY); + if (mz == NULL) { + sz = sizeof(struct event_ml_adapter *) * RTE_EVENT_ML_ADAPTER_MAX_INSTANCE; + sz = RTE_ALIGN(sz, RTE_CACHE_LINE_SIZE); + + mz = rte_memzone_reserve_aligned(ML_ADAPTER_ARRAY, sz, rte_socket_id(), 0, + RTE_CACHE_LINE_SIZE); + if (mz == NULL) { + RTE_EDEV_LOG_ERR("Failed to reserve memzone : %s, err = %d", + ML_ADAPTER_ARRAY, rte_errno); + return -rte_errno; + } + } + + event_ml_adapter = mz->addr; + + return 0; +} + +static inline int +emla_circular_buffer_init(const char *name, struct ml_ops_circular_buffer *buf, uint16_t sz) +{ + buf->op_buffer = rte_zmalloc(name, sizeof(struct rte_ml_op *) * sz, 0); + if (buf->op_buffer == NULL) + return -ENOMEM; + + buf->size = sz; + + return 0; +} + +static inline void +emla_circular_buffer_free(struct ml_ops_circular_buffer *buf) +{ + rte_free(buf->op_buffer); +} + +static int +emla_default_config_cb(uint8_t id, uint8_t evdev_id, struct rte_event_ml_adapter_conf *conf, + void *arg) +{ + struct rte_event_port_conf *port_conf; + struct rte_event_dev_config dev_conf; + struct event_ml_adapter *adapter; + struct rte_eventdev *dev; + uint8_t port_id; + int started; + int ret; + + adapter = emla_id_to_adapter(id); + if (adapter == NULL) + return -EINVAL; + + dev = &rte_eventdevs[adapter->eventdev_id]; + dev_conf = dev->data->dev_conf; + + started = dev->data->dev_started; + if (started) + rte_event_dev_stop(evdev_id); + + port_id = dev_conf.nb_event_ports; + dev_conf.nb_event_ports += 1; + + port_conf = arg; + if (port_conf->event_port_cfg & RTE_EVENT_PORT_CFG_SINGLE_LINK) + dev_conf.nb_single_link_event_port_queues += 1; + + ret = rte_event_dev_configure(evdev_id, &dev_conf); + if (ret) { + RTE_EDEV_LOG_ERR("Failed to configure event dev %u", evdev_id); + if (started) { + if (rte_event_dev_start(evdev_id)) + return -EIO; + } + return ret; + } + + ret = rte_event_port_setup(evdev_id, port_id, port_conf); + if (ret) { + RTE_EDEV_LOG_ERR("Failed to setup event port %u", port_id); + return ret; + } + + conf->event_port_id = port_id; + conf->max_nb = ML_DEFAULT_MAX_NB; + if (started) + ret = rte_event_dev_start(evdev_id); + + adapter->default_cb_arg = 1; + adapter->event_port_id = conf->event_port_id; + + return ret; +} + +int +rte_event_ml_adapter_create_ext(uint8_t id, uint8_t evdev_id, rte_event_ml_adapter_conf_cb conf_cb, + enum rte_event_ml_adapter_mode mode, void *conf_arg) +{ + struct rte_event_dev_info dev_info; + struct event_ml_adapter *adapter; + char name[ML_ADAPTER_NAME_LEN]; + int socket_id; + uint8_t i; + int ret; + + if (!emla_valid_id(id)) { + RTE_EDEV_LOG_ERR("Invalid ML adapter id = %d", id); + return -EINVAL; + } + + RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(evdev_id, -EINVAL); + + if (conf_cb == NULL) + return -EINVAL; + + if (event_ml_adapter == NULL) { + ret = emla_array_init(); + if (ret) + return ret; + } + + adapter = emla_id_to_adapter(id); + if (adapter != NULL) { + RTE_EDEV_LOG_ERR("ML adapter ID %d already exists!", id); + return -EEXIST; + } + + socket_id = rte_event_dev_socket_id(evdev_id); + snprintf(name, ML_ADAPTER_NAME_LEN, "rte_event_ml_adapter_%d", id); + adapter = rte_zmalloc_socket(name, sizeof(struct event_ml_adapter), RTE_CACHE_LINE_SIZE, + socket_id); + if (adapter == NULL) { + RTE_EDEV_LOG_ERR("Failed to get mem for event ML adapter!"); + return -ENOMEM; + } + + if (emla_circular_buffer_init("emla_circular_buffer", &adapter->ebuf, + ML_ADAPTER_BUFFER_SIZE)) { + RTE_EDEV_LOG_ERR("Failed to get memory for event adapter circular buffer"); + rte_free(adapter); + return -ENOMEM; + } + + ret = rte_event_dev_info_get(evdev_id, &dev_info); + if (ret < 0) { + RTE_EDEV_LOG_ERR("Failed to get info for eventdev %d: %s", evdev_id, + dev_info.driver_name); + emla_circular_buffer_free(&adapter->ebuf); + rte_free(adapter); + return ret; + } + + adapter->eventdev_id = evdev_id; + adapter->mode = mode; + rte_strlcpy(adapter->mem_name, name, ML_ADAPTER_NAME_LEN); + adapter->socket_id = socket_id; + adapter->conf_cb = conf_cb; + adapter->conf_arg = conf_arg; + adapter->mldevs = rte_zmalloc_socket(adapter->mem_name, + rte_ml_dev_count() * sizeof(struct ml_device_info), 0, + socket_id); + if (adapter->mldevs == NULL) { + RTE_EDEV_LOG_ERR("Failed to get memory for ML devices"); + emla_circular_buffer_free(&adapter->ebuf); + rte_free(adapter); + return -ENOMEM; + } + + rte_spinlock_init(&adapter->lock); + for (i = 0; i < rte_ml_dev_count(); i++) + adapter->mldevs[i].dev = rte_ml_dev_pmd_get_dev(i); + + event_ml_adapter[id] = adapter; + + return 0; +} + +int +rte_event_ml_adapter_create(uint8_t id, uint8_t evdev_id, struct rte_event_port_conf *port_config, + enum rte_event_ml_adapter_mode mode) +{ + struct rte_event_port_conf *pc; + int ret; + + if (port_config == NULL) + return -EINVAL; + + if (!emla_valid_id(id)) { + RTE_EDEV_LOG_ERR("Invalid ML adapter id = %d", id); + return -EINVAL; + } + + pc = rte_malloc(NULL, sizeof(struct rte_event_port_conf), 0); + if (pc == NULL) + return -ENOMEM; + + rte_memcpy(pc, port_config, sizeof(struct rte_event_port_conf)); + ret = rte_event_ml_adapter_create_ext(id, evdev_id, emla_default_config_cb, mode, pc); + if (ret != 0) + rte_free(pc); + + return ret; +} + +int +rte_event_ml_adapter_free(uint8_t id) +{ + struct event_ml_adapter *adapter; + + if (!emla_valid_id(id)) { + RTE_EDEV_LOG_ERR("Invalid ML adapter id = %d", id); + return -EINVAL; + } + + adapter = emla_id_to_adapter(id); + if (adapter == NULL) + return -EINVAL; + + if (adapter->default_cb_arg) + rte_free(adapter->conf_arg); + + rte_free(adapter->mldevs); + rte_free(adapter); + event_ml_adapter[id] = NULL; + + return 0; +}