@@ -4,3 +4,320 @@
#include "rte_event_ml_adapter.h"
#include "rte_eventdev.h"
+#include <rte_mldev.h>
+
+#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;
+}