Updated MVTVM layer of the driver to call TVM C runtime API functions, instead on the TVMDP wrapper library APIs.
Drop all dependencies on TVMDP wrapper library. Signed-off-by: Srikanth Yalavarthi <[email protected]> --- doc/guides/mldevs/cnxk.rst | 35 +- drivers/ml/cnxk/cnxk_ml_io.h | 20 +- drivers/ml/cnxk/cnxk_ml_ops.c | 12 +- drivers/ml/cnxk/meson.build | 14 +- drivers/ml/cnxk/mvtvm_ml_dev.h | 3 - drivers/ml/cnxk/mvtvm_ml_model.c | 638 ++++++++++++++++++++++++++++--- drivers/ml/cnxk/mvtvm_ml_model.h | 81 +++- drivers/ml/cnxk/mvtvm_ml_ops.c | 440 ++++++++++++++------- drivers/ml/cnxk/mvtvm_ml_ops.h | 5 +- drivers/ml/cnxk/mvtvm_ml_stubs.c | 17 - drivers/ml/cnxk/mvtvm_ml_stubs.h | 2 - 11 files changed, 985 insertions(+), 282 deletions(-) diff --git a/doc/guides/mldevs/cnxk.rst b/doc/guides/mldevs/cnxk.rst index fc1bcd9cdb4..17e58d81c0b 100644 --- a/doc/guides/mldevs/cnxk.rst +++ b/doc/guides/mldevs/cnxk.rst @@ -111,13 +111,13 @@ on CPU cores or hardware accelerators. .. note:: - DPDK CNXK ML driver requires TVM version 0.10.0 + DPDK CNXK ML driver requires TVM version legacy-v0.19.post branch. .. code-block:: console git clone https://github.com/apache/tvm.git cd tvm - git checkout v0.11.0 -b v0.11.0 + git checkout legacy-v0.19.post -b legacy-v0.19.post git submodule update --init cmake -S ./ -B build \ -DCMAKE_INSTALL_PREFIX=<install_prefix> \ @@ -135,37 +135,6 @@ When cross-compiling, more options must be provided to CMake: -DCMAKE_FIND_ROOT_PATH_MODE_PROGRAM=NEVER \ -DCMAKE_FIND_ROOT_PATH_MODE_LIBRARY=ONLY -TVMDP -~~~~~ - - Marvell's `TVM Dataplane Library <https://github.com/MarvellEmbeddedProcessors/tvmdp>`_ - works as an interface between TVM runtime and DPDK drivers. - TVMDP library provides a simplified C interface - for TVM's runtime based on C++. - -.. note:: - - TVMDP library is dependent on TVM, dlpack, jansson and dmlc-core libraries. - -.. code-block:: console - - git clone https://github.com/MarvellEmbeddedProcessors/tvmdp.git - cd tvmdp - git checkout main - cmake -S ./ -B build \ - -DCMAKE_INSTALL_PREFIX=<install_prefix> \ - -DBUILD_SHARED_LIBS=ON - make -C build - make -C build install - -When cross-compiling, more options must be provided to CMake: - -.. code-block:: console - - -DCMAKE_C_COMPILER=aarch64-linux-gnu-gcc \ - -DCMAKE_CXX_COMPILER=aarch64-linux-gnu-g++ \ - -DCMAKE_FIND_ROOT_PATH=<install_prefix> - libarchive ~~~~~~~~~~ diff --git a/drivers/ml/cnxk/cnxk_ml_io.h b/drivers/ml/cnxk/cnxk_ml_io.h index 83329c237aa..17f5b4619f0 100644 --- a/drivers/ml/cnxk/cnxk_ml_io.h +++ b/drivers/ml/cnxk/cnxk_ml_io.h @@ -6,7 +6,7 @@ #define _CNXK_ML_IO_H_ #ifdef RTE_MLDEV_CNXK_ENABLE_MVTVM -#include <tvmdp.h> +#include <dlpack/dlpack.h> #endif #include <rte_mldev.h> @@ -16,7 +16,7 @@ /* Maximum number of layers per model */ #ifdef RTE_MLDEV_CNXK_ENABLE_MVTVM -#define ML_CNXK_MODEL_MAX_LAYERS TVMDP_MODEL_LAYERS_MAX +#define ML_CNXK_MODEL_MAX_LAYERS 128 #else #define ML_CNXK_MODEL_MAX_LAYERS 1 #endif @@ -41,7 +41,7 @@ struct cnxk_ml_io { /* Number of dimensions in shape */ uint32_t nb_dims; - /* Shape of input */ + /* Shape */ uint32_t shape[ML_CNXK_MODEL_MAX_DIMS]; /* Number of elements */ @@ -58,6 +58,20 @@ struct cnxk_ml_io { /* Zero point */ int64_t zero_point; + +#ifdef RTE_MLDEV_CNXK_ENABLE_MVTVM + /* Shape - int64_t */ + int64_t shape_i64[ML_CNXK_MODEL_MAX_DIMS]; + + /* Data type */ + DLDataType datatype; + + /* Model data type */ + DLDataType model_datatype; + + /* Device */ + DLDevice device; +#endif }; /* Model / Layer IO structure */ diff --git a/drivers/ml/cnxk/cnxk_ml_ops.c b/drivers/ml/cnxk/cnxk_ml_ops.c index 9958945670a..938982c7556 100644 --- a/drivers/ml/cnxk/cnxk_ml_ops.c +++ b/drivers/ml/cnxk/cnxk_ml_ops.c @@ -634,10 +634,6 @@ cnxk_ml_dev_configure(struct rte_ml_dev *dev, const struct rte_ml_dev_config *co } } - ret = mvtvm_ml_dev_configure(cnxk_mldev, conf); - if (ret != 0) - goto error; - /* Set device capabilities */ if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_PCI) cnxk_mldev->max_nb_layers = @@ -705,9 +701,6 @@ cnxk_ml_dev_close(struct rte_ml_dev *dev) /* Un-initialize xstats */ cnxk_ml_xstats_uninit(cnxk_mldev); - if (mvtvm_ml_dev_close(cnxk_mldev) != 0) - plt_err("Failed to close MVTVM ML Device"); - if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_PCI) { if (cn10k_ml_dev_close(cnxk_mldev) != 0) plt_err("Failed to close CN10K ML Device"); @@ -1234,7 +1227,7 @@ cnxk_ml_model_load(struct rte_ml_dev *dev, struct rte_ml_model_params *params, u model->layer[layer_id].glow.ocm_map.scratch_pages); #ifdef RTE_MLDEV_CNXK_ENABLE_MVTVM } else { - for (layer_id = 0; layer_id < model->mvtvm.metadata.model.nb_layers; layer_id++) { + for (layer_id = 0; layer_id < model->nb_layers; layer_id++) { if (model->layer[layer_id].type == ML_CNXK_LAYER_TYPE_MRVL) { total_wb_pages = total_wb_pages + model->layer[layer_id].glow.ocm_map.wb_pages; @@ -1256,8 +1249,7 @@ cnxk_ml_model_load(struct rte_ml_dev *dev, struct rte_ml_model_params *params, u model->layer[layer_id].glow.ocm_map.scratch_pages); #ifdef RTE_MLDEV_CNXK_ENABLE_MVTVM } else { - for (layer_id = 0; layer_id < model->mvtvm.metadata.model.nb_layers; - layer_id++) { + for (layer_id = 0; layer_id < model->nb_layers; layer_id++) { if (model->layer[layer_id].type == ML_CNXK_LAYER_TYPE_MRVL) { plt_ml_dbg( "layer_id = %u: wb_pages = %u, scratch_pages = %u", diff --git a/drivers/ml/cnxk/meson.build b/drivers/ml/cnxk/meson.build index ef7e21d7476..5f078bd4fd7 100644 --- a/drivers/ml/cnxk/meson.build +++ b/drivers/ml/cnxk/meson.build @@ -19,30 +19,24 @@ if not jansson_dep.found() enable_mvtvm = false endif -dlpack_dep = dependency('dlpack', method: 'cmake', required: false, cmake_args: 'CONFIG') +dlpack_dep = dependency('dlpack', method: 'cmake', required: false) if not dlpack_dep.found() message('drivers/ml/cnxk: dlpack not found') enable_mvtvm = false endif -dmlc_dep = dependency('dmlc', method: 'cmake', required: false, cmake_args: 'CONFIG') +dmlc_dep = dependency('dmlc', method: 'cmake', required: false) if not dmlc_dep.found() message('drivers/ml/cnxk: dmlc not found') enable_mvtvm = false endif -tvm_dep = dependency('tvm', method: 'cmake', required: false, cmake_args: 'CONFIG', modules : ['tvm::tvm_runtime']) +tvm_dep = dependency('tvm', method: 'cmake', required: false, modules : ['tvm::tvm_runtime']) if not tvm_dep.found() message('drivers/ml/cnxk: tvm_runtime not found') enable_mvtvm = false endif -tvmdp_dep = dependency('tvmdp', method: 'pkg-config', required: false) -if not tvmdp_dep.found() - message('drivers/ml/cnxk: tvmdp not found') - enable_mvtvm = false -endif - sources = files( 'cn10k_ml_dev.c', 'cn10k_ml_ops.c', @@ -68,10 +62,10 @@ sources += files( ) ext_deps += jansson_dep +ext_deps += libarchive ext_deps += dlpack_dep ext_deps += dmlc_dep ext_deps += tvm_dep -ext_deps += tvmdp_dep stdcpp_dep = cc.find_library('stdc++', required: true) if not cc.links(min_c_code, dependencies: stdcpp_dep) error('broken dependency, "libstdc++"') diff --git a/drivers/ml/cnxk/mvtvm_ml_dev.h b/drivers/ml/cnxk/mvtvm_ml_dev.h index 6922c193372..05e30f094cd 100644 --- a/drivers/ml/cnxk/mvtvm_ml_dev.h +++ b/drivers/ml/cnxk/mvtvm_ml_dev.h @@ -19,9 +19,6 @@ extern struct rte_ml_dev_ops cnxk_ml_ops; /* Maximum number of descriptors per queue-pair */ #define ML_MVTVM_MAX_DESC_PER_QP 1024 -/* Maximum number of inputs / outputs per model */ -#define ML_MVTVM_MAX_INPUT_OUTPUT 32 - /* Maximum number of segments for IO data */ #define ML_MVTVM_MAX_SEGMENTS 1 diff --git a/drivers/ml/cnxk/mvtvm_ml_model.c b/drivers/ml/cnxk/mvtvm_ml_model.c index 4c7aa906da0..e1946607629 100644 --- a/drivers/ml/cnxk/mvtvm_ml_model.c +++ b/drivers/ml/cnxk/mvtvm_ml_model.c @@ -2,6 +2,12 @@ * Copyright (c) 2023 Marvell. */ +#include <errno.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + #include <archive.h> #include <archive_entry.h> @@ -23,6 +29,7 @@ enum cnxk_ml_model_type mvtvm_ml_model_type_get(struct rte_ml_model_params *params) { bool object_found[ML_MVTVM_MODEL_OBJECT_MAX] = {false, false, false}; + enum cnxk_ml_model_type model_type; struct archive_entry *entry; struct archive *a; uint8_t i; @@ -33,9 +40,10 @@ mvtvm_ml_model_type_get(struct rte_ml_model_params *params) archive_read_support_filter_all(a); archive_read_support_format_all(a); + model_type = ML_CNXK_MODEL_TYPE_UNKNOWN; ret = archive_read_open_memory(a, params->addr, params->size); if (ret != ARCHIVE_OK) - return ML_CNXK_MODEL_TYPE_UNKNOWN; + goto cleanup; /* Parse buffer for available objects */ while (archive_read_next_header(a, &entry) == ARCHIVE_OK) { @@ -51,11 +59,18 @@ mvtvm_ml_model_type_get(struct rte_ml_model_params *params) for (i = 0; i < ML_MVTVM_MODEL_OBJECT_MAX; i++) { if (!object_found[i]) { plt_err("Object %s not found in archive!", mvtvm_object_list[i]); - return ML_CNXK_MODEL_TYPE_INVALID; + model_type = ML_CNXK_MODEL_TYPE_INVALID; + goto cleanup; } } - return ML_CNXK_MODEL_TYPE_TVM; + model_type = ML_CNXK_MODEL_TYPE_TVM; + +cleanup: + archive_read_close(a); + archive_read_free(a); + + return model_type; } int @@ -67,14 +82,18 @@ mvtvm_ml_model_blob_parse(struct rte_ml_model_params *params, struct mvtvm_ml_mo uint8_t i; int ret; + memset(object, 0, ML_MVTVM_MODEL_OBJECT_MAX * sizeof(*object)); + /* Open archive */ a = archive_read_new(); archive_read_support_filter_all(a); archive_read_support_format_all(a); ret = archive_read_open_memory(a, params->addr, params->size); - if (ret != ARCHIVE_OK) - return archive_errno(a); + if (ret != ARCHIVE_OK) { + ret = archive_errno(a); + goto cleanup; + } /* Read archive */ while (archive_read_next_header(a, &entry) == ARCHIVE_OK) { @@ -84,11 +103,16 @@ mvtvm_ml_model_blob_parse(struct rte_ml_model_params *params, struct mvtvm_ml_mo memcpy(object[i].name, mvtvm_object_list[i], RTE_ML_STR_MAX); object[i].size = archive_entry_size(entry); object[i].buffer = rte_malloc(NULL, object[i].size, 0); + if (object[i].buffer == NULL) { + ret = -ENOMEM; + goto error; + } if (archive_read_data(a, object[i].buffer, object[i].size) != object[i].size) { plt_err("Failed to read object from model archive: %s", object[i].name); + ret = -EINVAL; goto error; } object_found[i] = true; @@ -101,17 +125,24 @@ mvtvm_ml_model_blob_parse(struct rte_ml_model_params *params, struct mvtvm_ml_mo for (i = 0; i < ML_MVTVM_MODEL_OBJECT_MAX; i++) { if (!object_found[i]) { plt_err("Object %s not found in archive!", mvtvm_object_list[i]); + ret = -EINVAL; goto error; } } - return 0; + ret = 0; + goto cleanup; error: for (i = 0; i < ML_MVTVM_MODEL_OBJECT_MAX; i++) { - rte_free(object[i].buffer); + if (object[i].buffer != NULL) + rte_free(object[i].buffer); } - return -EINVAL; +cleanup: + archive_read_close(a); + archive_read_free(a); + + return ret; } int @@ -119,12 +150,12 @@ mvtvm_ml_model_get_layer_id(struct cnxk_ml_model *model, const char *layer_name, { uint16_t i; - for (i = 0; i < model->mvtvm.metadata.model.nb_layers; i++) { + for (i = 0; i < model->nb_layers; i++) { if (strcmp(model->layer[i].name, layer_name) == 0) break; } - if (i == model->mvtvm.metadata.model.nb_layers) { + if (i == model->nb_layers) { plt_err("Invalid layer name: %s", layer_name); return -EINVAL; } @@ -139,6 +170,506 @@ mvtvm_ml_model_get_layer_id(struct cnxk_ml_model *model, const char *layer_name, return 0; } +static void +mvtvm_ml_param_names_free(struct mvtvm_ml_param_names *param_names) +{ + size_t i; + + for (i = 0; i < param_names->count; i++) + free(param_names->name[i]); + + free(param_names->name); + param_names->name = NULL; + param_names->count = 0; +} + +static int +mvtvm_ml_blob_read_u64(const uint8_t *blob, size_t blob_size, size_t *offset, uint64_t *value) +{ + if (*offset + sizeof(*value) > blob_size) + return -EINVAL; + + memcpy(value, blob + *offset, sizeof(*value)); + *offset += sizeof(*value); + + return 0; +} + +static int +mvtvm_ml_param_names_parse(const uint8_t *blob, size_t blob_size, + struct mvtvm_ml_param_names *param_names) +{ + uint64_t magic = 0; + uint64_t reserved = 0; + uint64_t count = 0; + size_t offset = 0; + int ret; + size_t i; + + memset(param_names, 0, sizeof(*param_names)); + + ret = mvtvm_ml_blob_read_u64(blob, blob_size, &offset, &magic); + if (ret != 0) + return ret; + + if (magic != TVM_NDARRAY_LIST_MAGIC) + return -EINVAL; + + ret = mvtvm_ml_blob_read_u64(blob, blob_size, &offset, &reserved); + if (ret != 0) + return ret; + + ret = mvtvm_ml_blob_read_u64(blob, blob_size, &offset, &count); + if (ret != 0) + return ret; + + if (count > SIZE_MAX / sizeof(*param_names->name)) + return -EINVAL; + + param_names->name = calloc(count, sizeof(*param_names->name)); + if (count != 0 && param_names->name == NULL) + return -ENOMEM; + + param_names->count = count; + for (i = 0; i < count; i++) { + uint64_t name_len = 0; + + ret = mvtvm_ml_blob_read_u64(blob, blob_size, &offset, &name_len); + if (ret != 0) + goto error; + + if (name_len == SIZE_MAX) { + ret = -EINVAL; + goto error; + } + + if (offset + name_len > blob_size) { + ret = -EINVAL; + goto error; + } + + param_names->name[i] = calloc(name_len + 1, 1); + if (param_names->name[i] == NULL) { + ret = -ENOMEM; + goto error; + } + + memcpy(param_names->name[i], blob + offset, name_len); + offset += name_len; + } + + return 0; + +error: + mvtvm_ml_param_names_free(param_names); + return ret; +} + +static int +mvtvm_ml_dtype_parse(const char *dtype_str, DLDataType *dtype) +{ + const char *lanes_str; + char base[32] = {0}; + long bits; + long lanes = 1; + + if (dtype_str == NULL || dtype == NULL) + return -EINVAL; + + lanes_str = strchr(dtype_str, 'x'); + if (lanes_str != NULL) { + size_t base_len = lanes_str - dtype_str; + + if (base_len >= sizeof(base)) + return -EINVAL; + memcpy(base, dtype_str, base_len); + lanes = strtol(lanes_str + 1, NULL, 10); + if (lanes <= 0 || lanes > UINT16_MAX) + return -EINVAL; + } else { + snprintf(base, sizeof(base), "%s", dtype_str); + } + + memset(dtype, 0, sizeof(*dtype)); + dtype->lanes = (uint16_t)lanes; + + if (strncmp(base, "int", 3) == 0) { + bits = strtol(base + 3, NULL, 10); + dtype->code = kDLInt; + } else if (strncmp(base, "uint", 4) == 0) { + bits = strtol(base + 4, NULL, 10); + dtype->code = kDLUInt; + } else if (strncmp(base, "float", 5) == 0) { + bits = strtol(base + 5, NULL, 10); + dtype->code = kDLFloat; + } else if (strncmp(base, "bfloat", 6) == 0) { + bits = strtol(base + 6, NULL, 10); + dtype->code = kDLBfloat; + } else if (strcmp(base, "bool") == 0) { + bits = 1; + dtype->code = kDLUInt; + } else { + return -EINVAL; + } + + if (bits <= 0 || bits > UINT8_MAX) + return -EINVAL; + + dtype->bits = (uint8_t)bits; + + return 0; +} + +static int +mvtvm_ml_model_io_set(struct cnxk_ml_io *io, const char *name, json_t *shape, const char *dtype_str, + DLDevice device) +{ + size_t i; + int ret; + + memset(io, 0, sizeof(*io)); + if (name != NULL) + snprintf(io->name, sizeof(io->name), "%s", name); + + if (!json_is_array(shape)) + return -EINVAL; + + io->nb_dims = json_array_size(shape); + if (io->nb_dims > ML_CNXK_MODEL_MAX_DIMS) + return -ENOTSUP; + + for (i = 0; i < (size_t)io->nb_dims; i++) { + json_t *dim = json_array_get(shape, i); + + if (!json_is_integer(dim)) + return -EINVAL; + io->shape_i64[i] = json_integer_value(dim); + } + + ret = mvtvm_ml_dtype_parse(dtype_str, &io->datatype); + if (ret != 0) + return ret; + + io->model_datatype = io->datatype; + io->scale = 1.0f; + io->device = device; + + return 0; +} + +static int +mvtvm_ml_json_graph_get_arrays(json_t *json_parsed, json_t **nodes, json_t **arg_nodes, + json_t **heads, json_t **node_row_ptr, json_t **shape_values, + json_t **dtype_values) +{ + json_t *attrs; + json_t *shape_attr; + json_t *dtype_attr; + + *nodes = json_object_get(json_parsed, "nodes"); + *arg_nodes = json_object_get(json_parsed, "arg_nodes"); + *heads = json_object_get(json_parsed, "heads"); + *node_row_ptr = json_object_get(json_parsed, "node_row_ptr"); + attrs = json_object_get(json_parsed, "attrs"); + + if (!json_is_array(*nodes) || !json_is_array(*arg_nodes) || !json_is_array(*heads) || + !json_is_array(*node_row_ptr) || !json_is_object(attrs)) + return -EINVAL; + + if (json_array_size(*node_row_ptr) != json_array_size(*nodes) + 1) + return -EINVAL; + + shape_attr = json_object_get(attrs, "shape"); + dtype_attr = json_object_get(attrs, "dltype"); + if (!json_is_array(shape_attr) || json_array_size(shape_attr) < 2 || + !json_is_array(dtype_attr) || json_array_size(dtype_attr) < 2) + return -EINVAL; + + *shape_values = json_array_get(shape_attr, 1); + *dtype_values = json_array_get(dtype_attr, 1); + + if (!json_is_array(*shape_values) || !json_is_array(*dtype_values)) + return -EINVAL; + + return 0; +} + +int +mvtvm_ml_model_json_parse(struct cnxk_ml_model *model) +{ + struct mvtvm_ml_param_names param_names; + json_error_t json_error; + json_t *json_parsed; + json_t *json_nodes; + json_t *json_arg_nodes; + json_t *json_heads; + json_t *json_node_row_ptr; + json_t *json_shape_values; + json_t *json_dtype_values; + uint16_t nb_mrvl_layers; + uint16_t nb_llvm_layers; + DLDevice device; + int ret; + size_t i; + size_t j; + + /* Parse param names from params buffer */ + ret = mvtvm_ml_param_names_parse(model->mvtvm.params.buffer, model->mvtvm.params.size, + ¶m_names); + if (ret != 0) + return ret; + + /* Load JSON graph (single load for both stages) */ + json_parsed = json_loadb((const char *)model->mvtvm.json.buffer, model->mvtvm.json.size, 0, + &json_error); + if (json_parsed == NULL) { + mvtvm_ml_param_names_free(¶m_names); + plt_err("TVM runtime: Failed to parse JSON graph, model_id = %u", model->model_id); + return -EINVAL; + } + + /* Parse nodes to extract layer info */ + json_nodes = json_object_get(json_parsed, "nodes"); + if (!json_is_array(json_nodes)) { + ret = -EINVAL; + plt_err("TVM runtime: Failed to parse JSON nodes, model_id = %u, error = %d", + model->model_id, ret); + goto error; + } + + model->nb_layers = 0; + nb_mrvl_layers = 0; + nb_llvm_layers = 0; + for (i = 0; i < json_array_size(json_nodes); i++) { + json_t *node = json_array_get(json_nodes, i); + json_t *op = json_object_get(node, "op"); + json_t *name; + json_t *attrs; + json_t *compiler; + + if (!json_is_string(op) || strcmp(json_string_value(op), "tvm_op") != 0) + continue; + + if (model->nb_layers >= ML_CNXK_MODEL_MAX_LAYERS) { + ret = -ENOTSUP; + plt_err("TVM runtime: Number of layers exceeds maximum (%u), model_id = %u, error = %d", + ML_CNXK_MODEL_MAX_LAYERS, model->model_id, ret); + goto error; + } + + name = json_object_get(node, "name"); + if (!json_is_string(name)) { + ret = -EINVAL; + plt_err("TVM runtime: Failed to parse JSON node name, model_id = %u, error = %d", + model->model_id, ret); + goto error; + } + + if (json_string_value(name) != NULL) + snprintf(model->layer[model->nb_layers].name, + sizeof(model->layer[model->nb_layers].name), "%s", + json_string_value(name)); + else + snprintf(model->layer[model->nb_layers].name, + sizeof(model->layer[model->nb_layers].name), "tvm_layer_%u", + model->nb_layers); + + attrs = json_object_get(node, "attrs"); + compiler = json_is_object(attrs) ? json_object_get(attrs, "Compiler") : NULL; + if (json_is_string(compiler)) { + if (strcmp(json_string_value(compiler), "mrvl") == 0 || + strcmp(json_string_value(compiler), "MRVL") == 0) { + model->layer[model->nb_layers].type = ML_CNXK_LAYER_TYPE_MRVL; + nb_mrvl_layers++; + } else { + model->layer[model->nb_layers].type = ML_CNXK_LAYER_TYPE_UNKNOWN; + } + } else { + model->layer[model->nb_layers].type = ML_CNXK_LAYER_TYPE_LLVM; + nb_llvm_layers++; + } + model->nb_layers++; + } + + /* Set model fields */ + snprintf(model->name, sizeof(model->name), "tvm_model_%u", model->model_id); + model->batch_size = 1; + + /* Validate layer counts */ + if ((nb_llvm_layers == 0) && (nb_mrvl_layers == 0)) { + plt_err("Invalid model, nb_llvm_layers = %u, nb_mrvl_layers = %u", nb_llvm_layers, + nb_mrvl_layers); + ret = -EINVAL; + goto error; + } + + if (nb_llvm_layers + nb_mrvl_layers != model->nb_layers) { + plt_err("Invalid model, nb_llvm_layers = %u, nb_mrvl_layers = %u, nb_layers = %u", + nb_llvm_layers, nb_mrvl_layers, model->nb_layers); + ret = -EINVAL; + goto error; + } + + /* Set model subtype */ + if ((nb_llvm_layers == 0) && (nb_mrvl_layers == 1)) + model->subtype = ML_CNXK_MODEL_SUBTYPE_TVM_MRVL; + else if ((nb_llvm_layers > 0) && (nb_mrvl_layers == 0)) + model->subtype = ML_CNXK_MODEL_SUBTYPE_TVM_LLVM; + else + model->subtype = ML_CNXK_MODEL_SUBTYPE_TVM_HYBRID; + + /* Parse I/O info from the same JSON graph */ + device.device_type = kDLCPU; + device.device_id = 0; + + ret = mvtvm_ml_json_graph_get_arrays(json_parsed, &json_nodes, &json_arg_nodes, &json_heads, + &json_node_row_ptr, &json_shape_values, + &json_dtype_values); + if (ret == 0) { + model->mvtvm.info.nb_inputs = 0; + model->mvtvm.info.nb_outputs = 0; + + for (i = 0; i < json_array_size(json_arg_nodes); i++) { + json_t *arg_node_idx = json_array_get(json_arg_nodes, i); + json_t *node; + json_t *shape; + json_t *dtype; + json_t *name; + json_int_t node_id; + + if (!json_is_integer(arg_node_idx)) { + ret = -EINVAL; + break; + } + + node_id = json_integer_value(arg_node_idx); + node = json_array_get(json_nodes, node_id); + shape = json_array_get(json_shape_values, node_id); + dtype = json_array_get(json_dtype_values, node_id); + name = json_object_get(node, "name"); + if (!json_is_object(node) || !json_is_array(shape) || + !json_is_string(dtype) || !json_is_string(name)) { + ret = -EINVAL; + break; + } + + for (j = 0; j < param_names.count; j++) { + if (strcmp(param_names.name[j], json_string_value(name)) == 0) + break; + } + + if (j < param_names.count) + continue; + + if (model->mvtvm.info.nb_inputs >= ML_CNXK_MODEL_MAX_INPUT_OUTPUT) { + ret = -ENOTSUP; + break; + } + + ret = mvtvm_ml_model_io_set( + &model->mvtvm.info.input[model->mvtvm.info.nb_inputs], + json_string_value(name), shape, json_string_value(dtype), device); + if (ret != 0) + break; + + model->mvtvm.info.nb_inputs++; + } + + for (i = 0; ret == 0 && i < json_array_size(json_heads); i++) { + json_t *head = json_array_get(json_heads, i); + json_t *node; + json_t *shape; + json_t *dtype; + json_t *name; + json_t *node_id_json; + json_t *output_idx_json; + json_t *entry_base_json; + json_t *entry_limit_json; + json_int_t node_id; + json_int_t output_idx; + json_int_t entry_base; + json_int_t entry_limit; + size_t entry_id; + + if (!json_is_array(head) || json_array_size(head) < 2) { + ret = -EINVAL; + break; + } + + node_id_json = json_array_get(head, 0); + output_idx_json = json_array_get(head, 1); + if (!json_is_integer(node_id_json) || !json_is_integer(output_idx_json)) { + ret = -EINVAL; + break; + } + + node_id = json_integer_value(node_id_json); + output_idx = json_integer_value(output_idx_json); + if (node_id < 0 || output_idx < 0) { + ret = -EINVAL; + break; + } + + node = json_array_get(json_nodes, (size_t)node_id); + entry_base_json = json_array_get(json_node_row_ptr, (size_t)node_id); + entry_limit_json = json_array_get(json_node_row_ptr, (size_t)node_id + 1); + if (!json_is_object(node) || !json_is_integer(entry_base_json) || + !json_is_integer(entry_limit_json)) { + ret = -EINVAL; + break; + } + + entry_base = json_integer_value(entry_base_json); + entry_limit = json_integer_value(entry_limit_json); + if (entry_base < 0 || entry_limit < entry_base) { + ret = -EINVAL; + break; + } + + if (output_idx >= (entry_limit - entry_base)) { + ret = -EINVAL; + break; + } + + entry_id = (size_t)entry_base + (size_t)output_idx; + shape = json_array_get(json_shape_values, entry_id); + dtype = json_array_get(json_dtype_values, entry_id); + name = json_object_get(node, "name"); + if (!json_is_array(shape) || !json_is_string(dtype) || + !json_is_string(name)) { + ret = -EINVAL; + break; + } + + if (model->mvtvm.info.nb_outputs >= ML_CNXK_MODEL_MAX_INPUT_OUTPUT) { + ret = -ENOTSUP; + break; + } + + ret = mvtvm_ml_model_io_set( + &model->mvtvm.info.output[model->mvtvm.info.nb_outputs], + json_string_value(name), shape, json_string_value(dtype), device); + if (ret != 0) + break; + + model->mvtvm.info.nb_outputs++; + } + } + + if (ret != 0) + plt_err("TVM runtime: Failed to get metadata, model_id = %u, error = %d", + model->model_id, ret); + + json_decref(json_parsed); + mvtvm_ml_param_names_free(¶m_names); + return ret; + +error: + json_decref(json_parsed); + mvtvm_ml_param_names_free(¶m_names); + return ret; +} + static enum rte_ml_io_type mvtvm_ml_io_type_map(DLDataType dltype) { @@ -185,32 +716,27 @@ mvtvm_ml_io_type_map(DLDataType dltype) void mvtvm_ml_model_io_info_set(struct cnxk_ml_model *model) { - struct tvmdp_model_metadata *metadata; int32_t i; - int32_t j; + uint32_t j; if (model->subtype == ML_CNXK_MODEL_SUBTYPE_TVM_MRVL) goto tvm_mrvl_model; - metadata = &model->mvtvm.metadata; - /* Inputs, set for layer_id = 0 */ - model->mvtvm.info.nb_inputs = metadata->model.num_input; model->mvtvm.info.total_input_sz_d = 0; model->mvtvm.info.total_input_sz_q = 0; - for (i = 0; i < metadata->model.num_input; i++) { - rte_strscpy(model->mvtvm.info.input[i].name, metadata->input[i].name, - TVMDP_NAME_STRLEN); + for (i = 0; i < model->mvtvm.info.nb_inputs; i++) { model->mvtvm.info.input[i].dtype = - mvtvm_ml_io_type_map(metadata->input[i].datatype); + mvtvm_ml_io_type_map(model->mvtvm.info.input[i].datatype); model->mvtvm.info.input[i].qtype = - mvtvm_ml_io_type_map(metadata->input[i].model_datatype); - model->mvtvm.info.input[i].nb_dims = metadata->input[i].ndim; + mvtvm_ml_io_type_map(model->mvtvm.info.input[i].model_datatype); model->mvtvm.info.input[i].nb_elements = 1; - for (j = 0; j < metadata->input[i].ndim; j++) { - model->mvtvm.info.input[i].shape[j] = metadata->input[i].shape[j]; - model->mvtvm.info.input[i].nb_elements *= metadata->input[i].shape[j]; + for (j = 0; j < model->mvtvm.info.input[i].nb_dims; j++) { + model->mvtvm.info.input[i].shape[j] = + PLT_U32_CAST(model->mvtvm.info.input[i].shape_i64[j]); + model->mvtvm.info.input[i].nb_elements *= + model->mvtvm.info.input[i].shape[j]; } model->mvtvm.info.input[i].sz_d = @@ -219,15 +745,14 @@ mvtvm_ml_model_io_info_set(struct cnxk_ml_model *model) model->mvtvm.info.input[i].sz_q = model->mvtvm.info.input[i].nb_elements * rte_ml_io_type_size_get(model->mvtvm.info.input[i].qtype); - model->mvtvm.info.input[i].scale = metadata->input[i].scale; model->mvtvm.info.total_input_sz_d += model->mvtvm.info.input[i].sz_d; model->mvtvm.info.total_input_sz_q += model->mvtvm.info.input[i].sz_q; - model->mvtvm.input_tensor[i].device = metadata->input[i].device; - model->mvtvm.input_tensor[i].ndim = metadata->input[i].ndim; - model->mvtvm.input_tensor[i].dtype = metadata->input[i].datatype; - model->mvtvm.input_tensor[i].shape = metadata->input[i].shape; + model->mvtvm.input_tensor[i].device = model->mvtvm.info.input[i].device; + model->mvtvm.input_tensor[i].ndim = model->mvtvm.info.input[i].nb_dims; + model->mvtvm.input_tensor[i].dtype = model->mvtvm.info.input[i].datatype; + model->mvtvm.input_tensor[i].shape = model->mvtvm.info.input[i].shape_i64; model->mvtvm.input_tensor[i].strides = NULL; model->mvtvm.input_tensor[i].byte_offset = 0; @@ -236,22 +761,20 @@ mvtvm_ml_model_io_info_set(struct cnxk_ml_model *model) } /* Outputs, set for nb_layers - 1 */ - model->mvtvm.info.nb_outputs = metadata->model.num_output; model->mvtvm.info.total_output_sz_d = 0; model->mvtvm.info.total_output_sz_q = 0; - for (i = 0; i < metadata->model.num_output; i++) { - rte_strscpy(model->mvtvm.info.output[i].name, metadata->output[i].name, - TVMDP_NAME_STRLEN); + for (i = 0; i < model->mvtvm.info.nb_outputs; i++) { model->mvtvm.info.output[i].dtype = - mvtvm_ml_io_type_map(metadata->output[i].datatype); + mvtvm_ml_io_type_map(model->mvtvm.info.output[i].datatype); model->mvtvm.info.output[i].qtype = - mvtvm_ml_io_type_map(metadata->output[i].model_datatype); - model->mvtvm.info.output[i].nb_dims = metadata->output[i].ndim; + mvtvm_ml_io_type_map(model->mvtvm.info.output[i].model_datatype); model->mvtvm.info.output[i].nb_elements = 1; - for (j = 0; j < metadata->output[i].ndim; j++) { - model->mvtvm.info.output[i].shape[j] = metadata->output[i].shape[j]; - model->mvtvm.info.output[i].nb_elements *= metadata->output[i].shape[j]; + for (j = 0; j < model->mvtvm.info.output[i].nb_dims; j++) { + model->mvtvm.info.output[i].shape[j] = + PLT_U32_CAST(model->mvtvm.info.output[i].shape_i64[j]); + model->mvtvm.info.output[i].nb_elements *= + model->mvtvm.info.output[i].shape[j]; } model->mvtvm.info.output[i].sz_d = @@ -260,15 +783,14 @@ mvtvm_ml_model_io_info_set(struct cnxk_ml_model *model) model->mvtvm.info.output[i].sz_q = model->mvtvm.info.output[i].nb_elements * rte_ml_io_type_size_get(model->mvtvm.info.output[i].qtype); - model->mvtvm.info.output[i].scale = metadata->output[i].scale; model->mvtvm.info.total_output_sz_d += model->mvtvm.info.output[i].sz_d; model->mvtvm.info.total_output_sz_q += model->mvtvm.info.output[i].sz_q; - model->mvtvm.output_tensor[i].device = metadata->output[i].device; - model->mvtvm.output_tensor[i].ndim = metadata->output[i].ndim; - model->mvtvm.output_tensor[i].dtype = metadata->output[i].datatype; - model->mvtvm.output_tensor[i].shape = metadata->output[i].shape; + model->mvtvm.output_tensor[i].device = model->mvtvm.info.output[i].device; + model->mvtvm.output_tensor[i].ndim = model->mvtvm.info.output[i].nb_dims; + model->mvtvm.output_tensor[i].dtype = model->mvtvm.info.output[i].datatype; + model->mvtvm.output_tensor[i].shape = model->mvtvm.info.output[i].shape_i64; model->mvtvm.output_tensor[i].strides = NULL; model->mvtvm.output_tensor[i].byte_offset = 0; @@ -293,7 +815,6 @@ mvtvm_ml_model_io_info_get(struct cnxk_ml_model *model, uint16_t layer_id) void mvtvm_ml_model_info_set(struct cnxk_ml_dev *cnxk_mldev, struct cnxk_ml_model *model) { - struct tvmdp_model_metadata *metadata; struct rte_ml_model_info *info; struct rte_ml_io_info *output; struct rte_ml_io_info *input; @@ -309,26 +830,23 @@ mvtvm_ml_model_info_set(struct cnxk_ml_dev *cnxk_mldev, struct cnxk_ml_model *mo if (model->subtype == ML_CNXK_MODEL_SUBTYPE_TVM_MRVL) goto tvm_mrvl_model; - metadata = &model->mvtvm.metadata; - rte_memcpy(info->name, metadata->model.name, TVMDP_NAME_STRLEN); - snprintf(info->version, RTE_ML_STR_MAX, "%u.%u.%u.%u", metadata->model.version[0], - metadata->model.version[1], metadata->model.version[2], - metadata->model.version[3]); + rte_memcpy(info->name, model->name, RTE_ML_STR_MAX); + snprintf(info->version, RTE_ML_STR_MAX, "%u.%u.%u.%u", 0, 0, 0, 0); info->model_id = model->model_id; info->device_id = cnxk_mldev->mldev->data->dev_id; info->io_layout = RTE_ML_IO_LAYOUT_SPLIT; info->min_batches = model->batch_size; info->max_batches = model->batch_size; - info->nb_inputs = metadata->model.num_input; + info->nb_inputs = model->mvtvm.info.nb_inputs; info->input_info = input; - info->nb_outputs = metadata->model.num_output; + info->nb_outputs = model->mvtvm.info.nb_outputs; info->output_info = output; info->wb_size = 0; /* Set input info */ for (i = 0; i < info->nb_inputs; i++) { - rte_memcpy(input[i].name, metadata->input[i].name, MRVL_ML_INPUT_NAME_LEN); - input[i].nb_dims = metadata->input[i].ndim; + rte_memcpy(input[i].name, model->mvtvm.info.input[i].name, MRVL_ML_INPUT_NAME_LEN); + input[i].nb_dims = model->mvtvm.info.input[i].nb_dims; input[i].shape = &model->mvtvm.info.input[i].shape[0]; input[i].type = model->mvtvm.info.input[i].qtype; input[i].nb_elements = model->mvtvm.info.input[i].nb_elements; @@ -340,15 +858,16 @@ mvtvm_ml_model_info_set(struct cnxk_ml_dev *cnxk_mldev, struct cnxk_ml_model *mo /* Set output info */ for (i = 0; i < info->nb_outputs; i++) { - rte_memcpy(output[i].name, metadata->output[i].name, MRVL_ML_OUTPUT_NAME_LEN); - output[i].nb_dims = metadata->output[i].ndim; + rte_memcpy(output[i].name, model->mvtvm.info.output[i].name, + MRVL_ML_OUTPUT_NAME_LEN); + output[i].nb_dims = model->mvtvm.info.output[i].nb_dims; output[i].shape = &model->mvtvm.info.output[i].shape[0]; output[i].type = model->mvtvm.info.output[i].qtype; output[i].nb_elements = model->mvtvm.info.output[i].nb_elements; output[i].size = model->mvtvm.info.output[i].nb_elements * rte_ml_io_type_size_get(model->mvtvm.info.output[i].qtype); - input[i].scale = model->mvtvm.info.output[i].scale; - input[i].zero_point = 0; + output[i].scale = model->mvtvm.info.output[i].scale; + output[i].zero_point = 0; } return; @@ -357,8 +876,7 @@ mvtvm_ml_model_info_set(struct cnxk_ml_dev *cnxk_mldev, struct cnxk_ml_model *mo cn10k_ml_model_info_set(cnxk_mldev, model, &model->mvtvm.info, &model->layer[0].glow.metadata); - metadata = &model->mvtvm.metadata; - strlcpy(info->name, metadata->model.name, TVMDP_NAME_STRLEN); + strlcpy(info->name, model->name, RTE_ML_STR_MAX); info->io_layout = RTE_ML_IO_LAYOUT_PACKED; } diff --git a/drivers/ml/cnxk/mvtvm_ml_model.h b/drivers/ml/cnxk/mvtvm_ml_model.h index 7ffce380945..1151b0a39ed 100644 --- a/drivers/ml/cnxk/mvtvm_ml_model.h +++ b/drivers/ml/cnxk/mvtvm_ml_model.h @@ -5,7 +5,21 @@ #ifndef _MVTVM_ML_MODEL_H_ #define _MVTVM_ML_MODEL_H_ -#include <tvmdp.h> +#include <dlpack/dlpack.h> +#include <jansson.h> +#include <rte_common.h> + +#if defined(RTE_CC_GCC) || defined(RTE_CC_CLANG) +__rte_diagnostic_push +RTE_PRAGMA(GCC diagnostic ignored "-Wstrict-prototypes") +#include <tvm/runtime/c_runtime_api.h> +__rte_diagnostic_pop +#else +#include <tvm/runtime/c_runtime_api.h> +#endif + +#include <stddef.h> +#include <stdint.h> #include <rte_mldev.h> @@ -18,19 +32,56 @@ struct cnxk_ml_layer; /* Maximum number of objects per model */ #define ML_MVTVM_MODEL_OBJECT_MAX 3 -/* Objects list */ -extern char mvtvm_object_list[ML_MVTVM_MODEL_OBJECT_MAX][RTE_ML_STR_MAX]; +/* Magic number for TVM parameter blobs. */ +#define TVM_NDARRAY_LIST_MAGIC 0xF7E58D4F05049CB7ULL -/* Model object structure */ +/* TVM parameter names structure */ +struct mvtvm_ml_param_names { + char **name; + size_t count; +}; + +/* TVM object / artifact info structure */ struct mvtvm_ml_model_object { /* Name */ char name[RTE_ML_STR_MAX]; - /* Temporary buffer */ + /* Buffer address */ uint8_t *buffer; /* Buffer size */ int64_t size; + + /* Offset */ + uint32_t offset; +}; + +/* Glow model callback functions */ +typedef int (*tvmrt_glow_layer_load_cb)(void *device, uint16_t model_id, const char *layer_name, + uint8_t *buffer, size_t size, uint16_t *index); +typedef int (*tvmrt_glow_layer_unload_cb)(void *device, uint16_t model_id, const char *layer_name); +typedef int (*tvmrt_io_alloc_cb)(void *device, uint16_t model_id, const char *layer_name, + uint64_t **input_qbuffer, uint64_t **output_qbuffer); +typedef int (*tvmrt_io_free_cb)(void *device, uint16_t model_id, const char *layer_name); +typedef int (*tvmrt_malloc_cb)(const char *name, size_t size, uint32_t align, void **addr); +typedef int (*tvmrt_free_cb)(const char *name); +typedef int (*tvmrt_quantize_cb)(void *device, uint16_t model_id, const char *layer_name, + const DLTensor **deq_tensor, void *qbuffer); +typedef int (*tvmrt_dequantize_cb)(void *device, uint16_t model_id, const char *layer_name, + void *qbuffer, const DLTensor **deq_tensor); +typedef int (*tvmrt_inference_cb)(void *device, uint16_t index, void *input, void *output, + uint16_t nb_batches); + +struct tvmrt_glow_callback { + tvmrt_glow_layer_load_cb tvmrt_glow_layer_load; + tvmrt_glow_layer_unload_cb tvmrt_glow_layer_unload; + tvmrt_io_alloc_cb tvmrt_io_alloc; + tvmrt_io_free_cb tvmrt_io_free; + tvmrt_malloc_cb tvmrt_malloc; + tvmrt_free_cb tvmrt_free; + tvmrt_quantize_cb tvmrt_quantize; + tvmrt_dequantize_cb tvmrt_dequantize; + tvmrt_inference_cb tvmrt_inference; }; /* Model fast-path stats */ @@ -55,15 +106,26 @@ struct mvtvm_ml_model_xstats { }; struct mvtvm_ml_model_data { - /* Model metadata */ - struct tvmdp_model_metadata metadata; - /* Model objects */ - struct tvmdp_model_object object; + struct mvtvm_ml_model_object so; + struct mvtvm_ml_model_object json; + struct mvtvm_ml_model_object params; /* TVM runtime callbacks */ struct tvmrt_glow_callback cb; + /* TVM Graph Module */ + TVMModuleHandle graph_module; + + /* Shared object memfd used to load the TVM module */ + int fd; + + /* TVM Function Handles */ + TVMFunctionHandle load_params; + TVMFunctionHandle set_input_zero_copy; + TVMFunctionHandle set_output_zero_copy; + TVMFunctionHandle run; + /* Model I/O info */ struct cnxk_ml_io_info info; @@ -86,5 +148,6 @@ void mvtvm_ml_model_io_info_set(struct cnxk_ml_model *model); struct cnxk_ml_io_info *mvtvm_ml_model_io_info_get(struct cnxk_ml_model *model, uint16_t layer_id); void mvtvm_ml_model_info_set(struct cnxk_ml_dev *cnxk_mldev, struct cnxk_ml_model *model); void mvtvm_ml_layer_print(struct cnxk_ml_dev *cnxk_mldev, struct cnxk_ml_layer *layer, FILE *fp); +int mvtvm_ml_model_json_parse(struct cnxk_ml_model *model); #endif /* _MVTVM_ML_MODEL_H_ */ diff --git a/drivers/ml/cnxk/mvtvm_ml_ops.c b/drivers/ml/cnxk/mvtvm_ml_ops.c index 80b22460db9..bc47a4bbd75 100644 --- a/drivers/ml/cnxk/mvtvm_ml_ops.c +++ b/drivers/ml/cnxk/mvtvm_ml_ops.c @@ -2,7 +2,17 @@ * Copyright (c) 2023 Marvell. */ +#include <errno.h> +#include <linux/limits.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/mman.h> +#include <unistd.h> + #include <dlpack/dlpack.h> +#include <jansson.h> #include <rte_common.h> #include <rte_cycles.h> @@ -19,6 +29,76 @@ /* ML model macros */ #define MVTVM_ML_MODEL_MEMZONE_NAME "ml_mvtvm_model_mz" +/* Shared memory file descriptor name */ +#define ML_MODEL_SHMFD_NAME "mvtvm_shmfd" + +/* Shared memory file descriptor path */ +#define ML_MODEL_SHMFD_PATH "/proc/%d/fd/%d" + +static int +mvtvm_ml_tvm_func_get(struct cnxk_ml_model *model, TVMModuleHandle module, const char *name, + TVMFunctionHandle *func) +{ + int ret; + + ret = TVMModGetFunction(module, name, 0, func); + if (ret != 0) { + plt_err("Model load failed, model_id = %u, ret = %d, msg = %s", model->model_id, + ret, TVMGetLastError()); + return ret; + } + + if (*func == NULL) { + ret = -ENOENT; + plt_err("Model load failed, model_id = %u, function '%s' not found", + model->model_id, name); + } + + return ret; +} + +static int +mvtvm_ml_tvm_func_call(struct cnxk_ml_model *model, TVMFunctionHandle func, const char *name, + TVMValue *values, int *types, int num_args, TVMValue *ret_val, int *ret_type, + int ret_type_code) +{ + int ret; + + ret = TVMFuncCall(func, values, types, num_args, ret_val, ret_type); + if (ret != 0) { + plt_err("Error calling TVM function '%s', model_id = %u, ret = %d, msg = %s", name, + model->model_id, ret, TVMGetLastError()); + return ret; + } + + if (*ret_type != ret_type_code) { + ret = -EINVAL; + plt_err("TVM function '%s' returned unexpected type, model_id = %u, expected = %d, " + "actual = %d", + name, model->model_id, ret_type_code, *ret_type); + } + + return ret; +} + +static void +mvtvm_ml_tvm_func_free(TVMFunctionHandle *func) +{ + if ((func != NULL) && (*func != NULL)) { + TVMFuncFree(*func); + *func = NULL; + } +} + +static void +mvtvm_ml_tvm_mod_free(TVMModuleHandle *mod) +{ + if ((mod != NULL) && (*mod != NULL)) { + TVMModFree(*mod); + *mod = NULL; + } +} + __rte_hot static void mvtvm_ml_set_poll_addr(struct cnxk_ml_req *req) { @@ -30,8 +110,8 @@ mvtvm_ml_model_xstat_name_set(struct cnxk_ml_dev *cnxk_mldev, struct cnxk_ml_mod uint16_t stat_id, uint16_t entry, char *suffix) { snprintf(cnxk_mldev->xstats.entries[stat_id].map.name, - sizeof(cnxk_mldev->xstats.entries[stat_id].map.name), "%s-%s-%s", - model->mvtvm.metadata.model.name, model_xstats[entry].name, suffix); + sizeof(cnxk_mldev->xstats.entries[stat_id].map.name), "%s-%s-%s", model->name, + model_xstats[entry].name, suffix); } #define ML_AVG_FOREACH_QP_MVTVM(cnxk_mldev, model, qp_id, value, count) \ @@ -106,43 +186,13 @@ mvtvm_ml_dev_info_get(struct cnxk_ml_dev *cnxk_mldev, struct rte_ml_dev_info *de dev_info->max_queue_pairs = mvtvm_mldev->max_nb_qpairs; dev_info->max_desc = ML_MVTVM_MAX_DESC_PER_QP; - dev_info->max_io = ML_MVTVM_MAX_INPUT_OUTPUT; + dev_info->max_io = ML_CNXK_MODEL_MAX_INPUT_OUTPUT; dev_info->max_segments = ML_MVTVM_MAX_SEGMENTS; dev_info->align_size = RTE_CACHE_LINE_SIZE; return 0; } -int -mvtvm_ml_dev_configure(struct cnxk_ml_dev *cnxk_mldev, const struct rte_ml_dev_config *conf) -{ - int ret; - - RTE_SET_USED(conf); - - /* Configure TVMDP library */ - ret = tvmdp_configure(cnxk_mldev->mldev->data->nb_models, rte_get_tsc_cycles); - if (ret != 0) - plt_err("TVMDP configuration failed, error = %d", ret); - - return ret; -} - -int -mvtvm_ml_dev_close(struct cnxk_ml_dev *cnxk_mldev) -{ - int ret; - - RTE_SET_USED(cnxk_mldev); - - /* Close TVMDP library configuration */ - ret = tvmdp_close(); - if (ret != 0) - plt_err("TVMDP close failed, error = %d", ret); - - return ret; -} - int mvtvm_ml_dev_dump(struct cnxk_ml_dev *cnxk_mldev, FILE *fp) { @@ -159,16 +209,26 @@ mvtvm_ml_model_load(struct cnxk_ml_dev *cnxk_mldev, struct rte_ml_model_params * struct mvtvm_ml_model_object object[ML_MVTVM_MODEL_OBJECT_MAX]; struct tvmrt_glow_callback *callback; char str[RTE_MEMZONE_NAMESIZE]; + char path[PATH_MAX]; const struct plt_memzone *mz; size_t model_object_size = 0; size_t model_xstats_size = 0; - uint16_t nb_mrvl_layers; - uint16_t nb_llvm_layers; - uint8_t layer_id = 0; uint64_t mz_size = 0; + TVMFunctionHandle create_fn = NULL; + TVMFunctionHandle register_cb_fn = NULL; + TVMModuleHandle module_so = NULL; + TVMByteArray tvm_params; + TVMValue ret_value = {0}; + TVMValue arg_values[4] = {0}; + TVMValue tvm_arg_values[1] = {0}; + int ret_type = kTVMNullptr; + int arg_types[4] = {0}; + int tvm_arg_types[1] = {0}; + DLDevice device; int ret; RTE_SET_USED(cnxk_mldev); + model->mvtvm.fd = -1; ret = mvtvm_ml_model_blob_parse(params, object); if (ret != 0) @@ -192,80 +252,39 @@ mvtvm_ml_model_load(struct cnxk_ml_dev *cnxk_mldev, struct rte_ml_model_params * } /* Copy mod.so */ - model->mvtvm.object.so.addr = mz->addr; - model->mvtvm.object.so.size = object[0].size; - rte_memcpy(model->mvtvm.object.so.name, object[0].name, TVMDP_NAME_STRLEN); - rte_memcpy(model->mvtvm.object.so.addr, object[0].buffer, object[0].size); + model->mvtvm.so.buffer = mz->addr; + model->mvtvm.so.size = object[0].size; + rte_memcpy(model->mvtvm.so.name, object[0].name, RTE_ML_STR_MAX); + rte_memcpy(model->mvtvm.so.buffer, object[0].buffer, object[0].size); rte_free(object[0].buffer); /* Copy mod.json */ - model->mvtvm.object.json.addr = - RTE_PTR_ADD(model->mvtvm.object.so.addr, - RTE_ALIGN_CEIL(model->mvtvm.object.so.size, RTE_CACHE_LINE_MIN_SIZE)); - model->mvtvm.object.json.size = object[1].size; - rte_memcpy(model->mvtvm.object.json.name, object[1].name, TVMDP_NAME_STRLEN); - rte_memcpy(model->mvtvm.object.json.addr, object[1].buffer, object[1].size); + model->mvtvm.json.buffer = + RTE_PTR_ADD(model->mvtvm.so.buffer, + RTE_ALIGN_CEIL(model->mvtvm.so.size, RTE_CACHE_LINE_MIN_SIZE)); + model->mvtvm.json.size = object[1].size; + rte_memcpy(model->mvtvm.json.name, object[1].name, RTE_ML_STR_MAX); + rte_memcpy(model->mvtvm.json.buffer, object[1].buffer, object[1].size); rte_free(object[1].buffer); /* Copy mod.params */ - model->mvtvm.object.params.addr = - RTE_PTR_ADD(model->mvtvm.object.json.addr, - RTE_ALIGN_CEIL(model->mvtvm.object.json.size, RTE_CACHE_LINE_MIN_SIZE)); - model->mvtvm.object.params.size = object[2].size; - rte_memcpy(model->mvtvm.object.params.name, object[2].name, TVMDP_NAME_STRLEN); - rte_memcpy(model->mvtvm.object.params.addr, object[2].buffer, object[2].size); + model->mvtvm.params.buffer = + RTE_PTR_ADD(model->mvtvm.json.buffer, + RTE_ALIGN_CEIL(model->mvtvm.json.size, RTE_CACHE_LINE_MIN_SIZE)); + model->mvtvm.params.size = object[2].size; + rte_memcpy(model->mvtvm.params.name, object[2].name, RTE_ML_STR_MAX); + rte_memcpy(model->mvtvm.params.buffer, object[2].buffer, object[2].size); rte_free(object[2].buffer); - /* Get metadata - stage 1 */ - ret = tvmdp_model_metadata_get_stage1(model->mvtvm.object.json.addr, - model->mvtvm.object.json.size, - &model->mvtvm.metadata); - if (ret != 0) { - plt_err("TVMDP: Failed to parse metadata - stage 1, model_id = %u, error = %d", - model->model_id, ret); - goto error; - } - - /* Set model fields */ - plt_strlcpy(model->name, model->mvtvm.metadata.model.name, TVMDP_NAME_STRLEN); - model->batch_size = 1; - model->nb_layers = model->mvtvm.metadata.model.nb_layers; - - /* Update layer info */ - nb_mrvl_layers = 0; - nb_llvm_layers = 0; - for (layer_id = 0; layer_id < model->mvtvm.metadata.model.nb_layers; layer_id++) { - rte_strscpy(model->layer[layer_id].name, - model->mvtvm.metadata.model.layer[layer_id].name, TVMDP_NAME_STRLEN); - if (strcmp(model->mvtvm.metadata.model.layer[layer_id].type, "mrvl") == 0 || - strcmp(model->mvtvm.metadata.model.layer[layer_id].type, "MRVL") == 0) { - model->layer[layer_id].type = ML_CNXK_LAYER_TYPE_MRVL; - nb_mrvl_layers++; - } else if (strcmp(model->mvtvm.metadata.model.layer[layer_id].type, "llvm") == 0 || - strcmp(model->mvtvm.metadata.model.layer[layer_id].type, "LLVM") == 0) { - model->layer[layer_id].type = ML_CNXK_LAYER_TYPE_LLVM; - nb_llvm_layers++; - } - } - - if ((nb_llvm_layers == 0) && (nb_mrvl_layers == 0)) { - plt_err("Invalid model, nb_llvm_layers = %u, nb_mrvl_layers = %u", nb_llvm_layers, - nb_mrvl_layers); + ret = mvtvm_ml_model_json_parse(model); + if (ret != 0) goto error; - } - - /* Set model subtype */ - if ((nb_llvm_layers == 0) && (nb_mrvl_layers == 1)) - model->subtype = ML_CNXK_MODEL_SUBTYPE_TVM_MRVL; - else if ((nb_llvm_layers > 0) && (nb_mrvl_layers == 0)) - model->subtype = ML_CNXK_MODEL_SUBTYPE_TVM_LLVM; - else - model->subtype = ML_CNXK_MODEL_SUBTYPE_TVM_HYBRID; if (cnxk_mldev->type == CNXK_ML_DEV_TYPE_VDEV && model->subtype != ML_CNXK_MODEL_SUBTYPE_TVM_LLVM) { plt_err("Unsupported model sub-type"); - return -ENOTSUP; + ret = -ENOTSUP; + goto error; } /* Set callback function array */ @@ -284,23 +303,120 @@ mvtvm_ml_model_load(struct cnxk_ml_dev *cnxk_mldev, struct rte_ml_model_params * callback = NULL; } - /* Initialize model in TVMDP */ - ret = tvmdp_model_load(cnxk_mldev, model->model_id, (void *)(&model->mvtvm.object), - callback); + /* Initialize model in TVM runtime */ + if (model->mvtvm.graph_module != NULL) { + ret = -EBUSY; + plt_err("TVM runtime: Model load failed, model_id = %u, error = %d", + model->model_id, ret); + goto error; + } + + snprintf(path, sizeof(path), "%s_%d_%u", ML_MODEL_SHMFD_NAME, getpid(), model->model_id); + model->mvtvm.fd = memfd_create(path, 0); + if (model->mvtvm.fd < 0) { + ret = (errno == 0) ? -EIO : -errno; + plt_err("TVM runtime: Model load failed, model_id = %u, error = %d", + model->model_id, ret); + goto error; + } + + if (write(model->mvtvm.fd, model->mvtvm.so.buffer, model->mvtvm.so.size) != + (ssize_t)model->mvtvm.so.size) { + ret = (errno == 0) ? -EIO : -errno; + plt_err("TVM runtime: Model load failed, model_id = %u, error = %d", + model->model_id, ret); + goto error; + } + + if (lseek(model->mvtvm.fd, 0, SEEK_SET) < 0) { + ret = (errno == 0) ? -EIO : -errno; + plt_err("TVM runtime: Model load failed, model_id = %u, error = %d", + model->model_id, ret); + goto error; + } + + snprintf(path, sizeof(path), ML_MODEL_SHMFD_PATH, getpid(), model->mvtvm.fd); + ret = TVMModLoadFromFile(path, "so", &module_so); if (ret != 0) { - plt_err("TVMDP: Model load failed, model_id = %u, error = %d", model->model_id, - ret); + plt_err("TVM runtime: Model load failed, model_id = %u, ret = %d, msg = %s", + model->model_id, ret, TVMGetLastError()); goto error; } - /* Get model metadata - stage 2 */ - ret = tvmdp_model_metadata_get_stage2(model->model_id, &model->mvtvm.metadata); + /* Set device info */ + device.device_type = kDLCPU; + device.device_id = 0; + + if (callback != NULL) { + ret = mvtvm_ml_tvm_func_get(model, module_so, "register_cb", ®ister_cb_fn); + if (ret != 0) + goto error; + + arg_values[0].v_handle = callback; + arg_types[0] = kTVMOpaqueHandle; + arg_values[1].v_handle = cnxk_mldev; + arg_types[1] = kTVMOpaqueHandle; + arg_values[2].v_int64 = model->model_id; + arg_types[2] = kDLInt; + + ret = mvtvm_ml_tvm_func_call(model, register_cb_fn, "register_cb", arg_values, + arg_types, 3, &ret_value, &ret_type, kTVMNullptr); + if (ret != 0) + goto error; + } + + ret = TVMFuncGetGlobal("tvm.graph_executor.create", &create_fn); if (ret != 0) { - plt_err("TVMDP: Failed to get metadata, model_id = %u, error = %d", - model->model_id, ret); + plt_err("TVM runtime: Model load failed, model_id = %u, ret = %d, msg = %s", + model->model_id, ret, TVMGetLastError()); goto error; } + arg_values[0].v_str = (const char *)model->mvtvm.json.buffer; + arg_types[0] = kTVMStr; + arg_values[1].v_handle = module_so; + arg_types[1] = kTVMModuleHandle; + arg_values[2].v_int64 = device.device_type; + arg_types[2] = kDLInt; + arg_values[3].v_int64 = device.device_id; + arg_types[3] = kDLInt; + + ret = mvtvm_ml_tvm_func_call(model, create_fn, "tvm.graph_executor.create", arg_values, + arg_types, 4, &ret_value, &ret_type, kTVMModuleHandle); + if (ret != 0) + goto error; + model->mvtvm.graph_module = ret_value.v_handle; + + ret = mvtvm_ml_tvm_func_get(model, model->mvtvm.graph_module, "load_params", + &model->mvtvm.load_params); + if (ret != 0) + goto error; + ret = mvtvm_ml_tvm_func_get(model, model->mvtvm.graph_module, "set_input_zero_copy", + &model->mvtvm.set_input_zero_copy); + if (ret != 0) + goto error; + ret = mvtvm_ml_tvm_func_get(model, model->mvtvm.graph_module, "set_output_zero_copy", + &model->mvtvm.set_output_zero_copy); + if (ret != 0) + goto error; + ret = mvtvm_ml_tvm_func_get(model, model->mvtvm.graph_module, "run", &model->mvtvm.run); + if (ret != 0) + goto error; + + mvtvm_ml_tvm_func_free(®ister_cb_fn); + mvtvm_ml_tvm_mod_free(&module_so); + + /* Load model parameters into TVM runtime */ + tvm_params.data = (const char *)model->mvtvm.params.buffer; + tvm_params.size = model->mvtvm.params.size; + tvm_arg_values[0].v_handle = &tvm_params; + tvm_arg_types[0] = kTVMBytes; + + ret = mvtvm_ml_tvm_func_call(model, model->mvtvm.load_params, "load_params", tvm_arg_values, + tvm_arg_types, 1, &ret_value, &ret_type, kTVMNullptr); + if (ret != 0) + goto error; + /* Update model I/O data */ mvtvm_ml_model_io_info_set(model); @@ -310,9 +426,9 @@ mvtvm_ml_model_load(struct cnxk_ml_dev *cnxk_mldev, struct rte_ml_model_params * /* Update model xstats name */ cnxk_ml_xstats_model_name_update(cnxk_mldev, model->model_id); - model->mvtvm.burst_xstats = RTE_PTR_ADD( - model->mvtvm.object.params.addr, - RTE_ALIGN_CEIL(model->mvtvm.object.params.size, RTE_CACHE_LINE_MIN_SIZE)); + model->mvtvm.burst_xstats = + RTE_PTR_ADD(model->mvtvm.params.buffer, + RTE_ALIGN_CEIL(model->mvtvm.params.size, RTE_CACHE_LINE_MIN_SIZE)); for (int qp_id = 0; qp_id < cnxk_mldev->mldev->data->nb_queue_pairs; qp_id++) { model->mvtvm.burst_xstats[qp_id].tvm_rt_latency_tot = 0; @@ -341,7 +457,20 @@ mvtvm_ml_model_load(struct cnxk_ml_dev *cnxk_mldev, struct rte_ml_model_params * return 0; error: - rte_memzone_free(mz); + mvtvm_ml_tvm_func_free(®ister_cb_fn); + if (model != NULL) { + mvtvm_ml_tvm_func_free(&model->mvtvm.load_params); + mvtvm_ml_tvm_func_free(&model->mvtvm.set_input_zero_copy); + mvtvm_ml_tvm_func_free(&model->mvtvm.set_output_zero_copy); + mvtvm_ml_tvm_func_free(&model->mvtvm.run); + mvtvm_ml_tvm_mod_free(&model->mvtvm.graph_module); + if (model->mvtvm.fd >= 0) + close(model->mvtvm.fd); + memset(&model->mvtvm, 0, sizeof(model->mvtvm)); + model->mvtvm.fd = -1; + } + mvtvm_ml_tvm_mod_free(&module_so); + plt_memzone_free(mz); return ret; } @@ -351,20 +480,28 @@ mvtvm_ml_model_unload(struct cnxk_ml_dev *cnxk_mldev, struct cnxk_ml_model *mode { char str[RTE_MEMZONE_NAMESIZE]; const struct plt_memzone *mz; - int ret; RTE_SET_USED(cnxk_mldev); - /* Initialize model in TVMDP */ - ret = tvmdp_model_unload(model->model_id); - if (ret != 0) { - plt_err("TVMDP: Model unload failed, model_id = %u, error = %d", model->model_id, - ret); - return ret; - } + /* Unload model from TVM runtime */ + if (model->model_id >= cnxk_mldev->mldev->data->nb_models) + return -EINVAL; + + if (model->mvtvm.graph_module == NULL) + return -EINVAL; + + mvtvm_ml_tvm_func_free(&model->mvtvm.load_params); + mvtvm_ml_tvm_func_free(&model->mvtvm.set_input_zero_copy); + mvtvm_ml_tvm_func_free(&model->mvtvm.set_output_zero_copy); + mvtvm_ml_tvm_func_free(&model->mvtvm.run); + mvtvm_ml_tvm_mod_free(&model->mvtvm.graph_module); + if (model->mvtvm.fd >= 0) + close(model->mvtvm.fd); + memset(&model->mvtvm, 0, sizeof(model->mvtvm)); + model->mvtvm.fd = -1; snprintf(str, RTE_MEMZONE_NAMESIZE, "%s_%u", MVTVM_ML_MODEL_MEMZONE_NAME, model->model_id); - mz = rte_memzone_lookup(str); + mz = plt_memzone_lookup(str); if (mz == NULL) { plt_err("Memzone lookup failed for TVM model: model_id = %u, mz = %s", model->model_id, str); @@ -455,13 +592,13 @@ mvtvm_ml_io_quantize(void *device, uint16_t model_id, const char *layer_name, #endif /* Get layer id */ - for (layer_id = 0; layer_id < model->mvtvm.metadata.model.nb_layers; layer_id++) { + for (layer_id = 0; layer_id < model->nb_layers; layer_id++) { if (strcmp(model->layer[layer_id].name, layer_name) == 0) break; } #ifdef CNXK_ML_DEV_DEBUG - if (layer_id == model->mvtvm.metadata.model.nb_layers) { + if (layer_id == model->nb_layers) { plt_err("Invalid layer name: %s", layer_name); return -EINVAL; } @@ -516,13 +653,13 @@ mvtvm_ml_io_dequantize(void *device, uint16_t model_id, const char *layer_name, } #endif - for (layer_id = 0; layer_id < model->mvtvm.metadata.model.nb_layers; layer_id++) { + for (layer_id = 0; layer_id < model->nb_layers; layer_id++) { if (strcmp(model->layer[layer_id].name, layer_name) == 0) break; } #ifdef CNXK_ML_DEV_DEBUG - if (layer_id == model->mvtvm.metadata.model.nb_layers) { + if (layer_id == model->nb_layers) { plt_err("Invalid layer name: %s", layer_name); return -EINVAL; } @@ -553,28 +690,69 @@ static int mvtvm_ml_model_run(struct cnxk_ml_model *model, struct rte_ml_op *op, struct cnxk_ml_req *req) { uint8_t i; + struct mvtvm_ml_result *run_result; + TVMValue arg_values[2] = {0}; + int arg_types[2] = {0}; + TVMValue ret_value = {0}; + int ret_type = kTVMNullptr; + int ret = 0; rte_memcpy(req->mvtvm_req.input_tensor, model->mvtvm.input_tensor, - model->mvtvm.metadata.model.num_input * sizeof(DLTensor)); - for (i = 0; i < model->mvtvm.metadata.model.num_input; i++) { + model->mvtvm.info.nb_inputs * sizeof(DLTensor)); + for (i = 0; i < model->mvtvm.info.nb_inputs; i++) { req->mvtvm_req.input_tensor[i].data = op->input[i]->addr; req->mvtvm_req.input_tensor[i].byte_offset = 0; } rte_memcpy(req->mvtvm_req.output_tensor, model->mvtvm.output_tensor, - model->mvtvm.metadata.model.num_output * sizeof(DLTensor)); - for (i = 0; i < model->mvtvm.metadata.model.num_output; i++) { + model->mvtvm.info.nb_outputs * sizeof(DLTensor)); + for (i = 0; i < model->mvtvm.info.nb_outputs; i++) { req->mvtvm_req.output_tensor[i].data = op->output[i]->addr; req->mvtvm_req.output_tensor[i].byte_offset = 0; } - tvmdp_model_run(model->model_id, model->mvtvm.metadata.model.num_input, - req->mvtvm_req.input_tensor, model->mvtvm.metadata.model.num_output, - req->mvtvm_req.output_tensor, &req->mvtvm_req.result, - &req->mvtvm_req.status); + run_result = &req->mvtvm_req.result; + run_result->stats.start_ns = rte_get_tsc_cycles(); + run_result->error_code = 0; + + for (i = 0; i < model->mvtvm.info.nb_inputs; i++) { + arg_values[0].v_int64 = i; + arg_types[0] = kDLInt; + arg_values[1].v_handle = &req->mvtvm_req.input_tensor[i]; + arg_types[1] = kTVMDLTensorHandle; + ret = mvtvm_ml_tvm_func_call(model, model->mvtvm.set_input_zero_copy, + "set_input_zero_copy", arg_values, arg_types, 2, + &ret_value, &ret_type, kTVMNullptr); + if (ret != 0) + goto out; + } + + for (i = 0; i < model->mvtvm.info.nb_outputs; i++) { + arg_values[0].v_int64 = i; + arg_types[0] = kDLInt; + arg_values[1].v_handle = &req->mvtvm_req.output_tensor[i]; + arg_types[1] = kTVMDLTensorHandle; + ret = mvtvm_ml_tvm_func_call(model, model->mvtvm.set_output_zero_copy, + "set_output_zero_copy", arg_values, arg_types, 2, + &ret_value, &ret_type, kTVMNullptr); + if (ret != 0) + goto out; + } + + ret = mvtvm_ml_tvm_func_call(model, model->mvtvm.run, "run", NULL, NULL, 0, &ret_value, + &ret_type, kTVMNullptr); + if (ret != 0) + goto out; + +out: + run_result->stats.end_ns = rte_get_tsc_cycles(); + req->mvtvm_req.status = 0x1; plt_write64(ML_CNXK_POLL_JOB_FINISH, req->status); + if (ret != 0) + run_result->error_code = -EIO; + return 0; } diff --git a/drivers/ml/cnxk/mvtvm_ml_ops.h b/drivers/ml/cnxk/mvtvm_ml_ops.h index d8f2f361fb1..593f4585b3c 100644 --- a/drivers/ml/cnxk/mvtvm_ml_ops.h +++ b/drivers/ml/cnxk/mvtvm_ml_ops.h @@ -7,11 +7,10 @@ #include <dlpack/dlpack.h> -#include <tvmdp.h> - #include <rte_mldev.h> #include "cnxk_ml_xstats.h" +#include "mvtvm_ml_model.h" struct cnxk_ml_dev; struct cnxk_ml_model; @@ -56,8 +55,6 @@ struct mvtvm_ml_req { }; int mvtvm_ml_dev_info_get(struct cnxk_ml_dev *mldev, struct rte_ml_dev_info *dev_info); -int mvtvm_ml_dev_configure(struct cnxk_ml_dev *cnxk_mldev, const struct rte_ml_dev_config *conf); -int mvtvm_ml_dev_close(struct cnxk_ml_dev *cnxk_mldev); int mvtvm_ml_dev_dump(struct cnxk_ml_dev *cnxk_mldev, FILE *fp); int mvtvm_ml_model_load(struct cnxk_ml_dev *cnxk_mldev, struct rte_ml_model_params *params, struct cnxk_ml_model *model); diff --git a/drivers/ml/cnxk/mvtvm_ml_stubs.c b/drivers/ml/cnxk/mvtvm_ml_stubs.c index 126a954c916..7c13fac42d6 100644 --- a/drivers/ml/cnxk/mvtvm_ml_stubs.c +++ b/drivers/ml/cnxk/mvtvm_ml_stubs.c @@ -76,23 +76,6 @@ mvtvm_ml_dev_info_get(struct cnxk_ml_dev *cnxk_mldev, struct rte_ml_dev_info *de return -ENOTSUP; } -int -mvtvm_ml_dev_configure(struct cnxk_ml_dev *cnxk_mldev, const struct rte_ml_dev_config *conf) -{ - RTE_SET_USED(cnxk_mldev); - RTE_SET_USED(conf); - - return 0; -} - -int -mvtvm_ml_dev_close(struct cnxk_ml_dev *cnxk_mldev) -{ - RTE_SET_USED(cnxk_mldev); - - return 0; -} - int mvtvm_ml_dev_dump(struct cnxk_ml_dev *cnxk_mldev, FILE *fp) { diff --git a/drivers/ml/cnxk/mvtvm_ml_stubs.h b/drivers/ml/cnxk/mvtvm_ml_stubs.h index 4220a963f2d..15985a75bf4 100644 --- a/drivers/ml/cnxk/mvtvm_ml_stubs.h +++ b/drivers/ml/cnxk/mvtvm_ml_stubs.h @@ -15,8 +15,6 @@ struct cnxk_ml_layer; enum cnxk_ml_model_type mvtvm_ml_model_type_get(struct rte_ml_model_params *params); int mvtvm_ml_dev_info_get(struct cnxk_ml_dev *cnxk_mldev, struct rte_ml_dev_info *dev_info); -int mvtvm_ml_dev_configure(struct cnxk_ml_dev *cnxk_mldev, const struct rte_ml_dev_config *conf); -int mvtvm_ml_dev_close(struct cnxk_ml_dev *cnxk_mldev); int mvtvm_ml_dev_dump(struct cnxk_ml_dev *cnxk_mldev, FILE *fp); int mvtvm_ml_model_load(struct cnxk_ml_dev *cnxk_mldev, struct rte_ml_model_params *params, struct cnxk_ml_model *model); -- 2.34.1
