From: Seungbae Shin Date: Thu, 25 Nov 2021 03:30:02 +0000 (+0900) Subject: Refactoring InferenceMLAPI::Load() X-Git-Tag: submit/tizen/20220105.080154~3 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=58bc5dba631b40f9e7784c3e9713162078696b0d;p=platform%2Fcore%2Fmultimedia%2Finference-engine-mlapi.git Refactoring InferenceMLAPI::Load() [Version] : 0.3.1 [Issue type] : Refactoring Change-Id: I370b08981fcdd79f916dfe9cc5ea4225ecf66764 --- diff --git a/packaging/inference-engine-mlapi.spec b/packaging/inference-engine-mlapi.spec index a9bce91..230705d 100644 --- a/packaging/inference-engine-mlapi.spec +++ b/packaging/inference-engine-mlapi.spec @@ -1,6 +1,6 @@ Name: inference-engine-mlapi Summary: ML Single API backend of NNStreamer for MediaVision -Version: 0.3.0 +Version: 0.3.1 Release: 0 Group: Multimedia/Libraries License: Apache-2.0 diff --git a/src/inference_engine_mlapi.cpp b/src/inference_engine_mlapi.cpp index 9a5c2f8..b9aeaf4 100644 --- a/src/inference_engine_mlapi.cpp +++ b/src/inference_engine_mlapi.cpp @@ -23,6 +23,7 @@ #include #include #include +#include // TODO. Below is test code. DO NOT use ML internal function. #define ENABLE_FAST @@ -199,86 +200,102 @@ namespace MLAPIImpl return INFERENCE_ENGINE_ERROR_NONE; } - int InferenceMLAPI::Load(std::vector model_paths, - inference_model_format_e model_format) + std::tuple InferenceMLAPI::GetNNFWInfo() { - LOGI("ENTER"); + switch (mPluginType) { + case INFERENCE_BACKEND_NPU_VIVANTE: + LOGI("Vivante tensor filter will be used."); + return std::make_tuple(ML_NNFW_TYPE_VIVANTE, ML_NNFW_HW_ANY); - std::string model_str(model_paths[0]); + case INFERENCE_BACKEND_ONE: + LOGI("NNFW tensor filter will be used."); - // TODO. Set NNFW backend type and HW type properly. + if (mTargetDevice == INFERENCE_TARGET_CPU) { + LOGI("Target device is NEON."); + return std::make_tuple(ML_NNFW_TYPE_NNFW, ML_NNFW_HW_CPU_NEON); + } else if (mTargetDevice == INFERENCE_TARGET_GPU) { + LOGI("Target device is GPU"); + return std::make_tuple(ML_NNFW_TYPE_NNFW, ML_NNFW_HW_GPU); + } - ml_nnfw_type_e nnfw_type = ML_NNFW_TYPE_NNFW; - ml_nnfw_hw_e nnfw_hw = ML_NNFW_HW_ANY; + LOGE("Invalid inference target device type."); + throw std::invalid_argument("invalid tensor type."); + + case INFERENCE_BACKEND_ARMNN: + LOGI("ARMNN tensor filter will be used."); + return std::make_tuple(ML_NNFW_TYPE_ARMNN, ML_NNFW_HW_ANY); + + case INFERENCE_BACKEND_TFLITE: + LOGI("TFLITE tensor filter will be used."); + return std::make_tuple(ML_NNFW_TYPE_TENSORFLOW_LITE, ML_NNFW_HW_ANY); + + case INFERENCE_BACKEND_SNPE: + LOGI("SNPE tensor filter will be used."); + return std::make_tuple(ML_NNFW_TYPE_SNPE, ML_NNFW_HW_ANY); + + default: + LOGE("Invalid plugin type."); + throw std::invalid_argument("invalid tensor type."); + } + } + + bool InferenceMLAPI::IsFileReadable(const std::string& path) + { + if (access(path.c_str(), R_OK) == -1) { + LOGE("file [%s] is not readable, errno(%d)", path.c_str(), errno); + return false; + } + + return true; + } + std::string InferenceMLAPI::GetModelPath(const std::vector& model_paths) + { switch (mPluginType) { case INFERENCE_BACKEND_NPU_VIVANTE: - nnfw_type = ML_NNFW_TYPE_VIVANTE; - nnfw_hw = ML_NNFW_HW_ANY; - LOGI("Vivante tensor filter will be used."); - - if (access(model_str.c_str(), R_OK) || - access(model_paths[1].c_str(), R_OK)) { - LOGE("model file path in [%s,%s]", model_str.c_str(), - model_paths[1].c_str()); - return INFERENCE_ENGINE_ERROR_INVALID_PATH; - } + if (!IsFileReadable(model_paths[0]) || + !IsFileReadable(model_paths[1])) + throw std::runtime_error("invalid path"); // ML Single API of MLAPI requires model_paths rule like below, // "so library file path,nb model file path" or vise versa. - model_str += "," + model_paths[1]; - break; + return model_paths[0] + "," + model_paths[1]; + case INFERENCE_BACKEND_ONE: + /* fall through */ case INFERENCE_BACKEND_ARMNN: + /* fall through */ case INFERENCE_BACKEND_TFLITE: + /* fall through */ case INFERENCE_BACKEND_SNPE: - if (mPluginType == INFERENCE_BACKEND_ONE) { - nnfw_type = ML_NNFW_TYPE_NNFW; - - if (mTargetDevice == INFERENCE_TARGET_CPU) { - nnfw_hw = ML_NNFW_HW_CPU_NEON; - LOGI("Target device is NEON."); - } else if (mTargetDevice == INFERENCE_TARGET_GPU) { - nnfw_hw = ML_NNFW_HW_GPU; - LOGI("Target device is GPU"); - } else { - LOGE("Invalid inference target device type."); - return INFERENCE_ENGINE_ERROR_INVALID_PARAMETER; - } - - LOGI("NNFW tensor filter will be used."); - } + if (!IsFileReadable(model_paths[0])) + throw std::runtime_error("invalid path"); + return model_paths[0]; - if (mPluginType == INFERENCE_BACKEND_ARMNN) { - nnfw_type = ML_NNFW_TYPE_ARMNN; - LOGI("ARMNN tensor filter will be used."); - } + default: + throw std::runtime_error("shouldn't be reach here"); + } + } - if (mPluginType == INFERENCE_BACKEND_TFLITE) { - nnfw_type = ML_NNFW_TYPE_TENSORFLOW_LITE; - LOGI("TFLITE tensor filter will be used."); - } + int InferenceMLAPI::Load(std::vector model_paths, + inference_model_format_e model_format) + { + LOGI("ENTER"); - if (mPluginType == INFERENCE_BACKEND_SNPE) { - nnfw_type = ML_NNFW_TYPE_SNPE; - nnfw_hw = ML_NNFW_HW_ANY; - LOGI("SNPE tensor filter will be used."); - } + std::string model_str; - if (access(model_str.c_str(), R_OK)) { - LOGE("model file path in [%s]", model_str.c_str()); - return INFERENCE_ENGINE_ERROR_INVALID_PATH; - } + ml_nnfw_type_e nnfw_type = ML_NNFW_TYPE_ANY; + ml_nnfw_hw_e nnfw_hw = ML_NNFW_HW_ANY; - break; - case INFERENCE_BACKEND_NNTRAINER: - nnfw_type = ML_NNFW_TYPE_NNTR_INF; - nnfw_hw = ML_NNFW_HW_ANY; - break; - // TODO. - default: - LOGE("Invalid plugin type."); + try { + std::tie(nnfw_type, nnfw_hw) = GetNNFWInfo(); + model_str = GetModelPath(model_paths); + } catch (const std::invalid_argument& ex) { + LOGE("Get NNFW info Error (%s)", ex.what()); return INFERENCE_ENGINE_ERROR_INVALID_PARAMETER; + } catch (const std::runtime_error& ex) { + LOGE("Get model path Error (%s)", ex.what()); + return INFERENCE_ENGINE_ERROR_INVALID_PATH; } LOGI("Model name = %s", model_str.c_str()); @@ -286,7 +303,7 @@ namespace MLAPIImpl ml_tensors_info_h in_info = NULL, out_info = NULL; // In case of nntrainer tensor filter, input and output tensor - // informaion is needed to load a given model. + // information is needed to load a given model. if (mPluginType == INFERENCE_BACKEND_NNTRAINER) { int ret = CreateMLAPITensorInfo(in_info, mInputProperty); if (ret != INFERENCE_ENGINE_ERROR_NONE) diff --git a/src/inference_engine_mlapi_private.h b/src/inference_engine_mlapi_private.h index d2eacb9..98ab53a 100644 --- a/src/inference_engine_mlapi_private.h +++ b/src/inference_engine_mlapi_private.h @@ -22,6 +22,7 @@ #include #include +#include #ifdef LOG_TAG #undef LOG_TAG @@ -84,6 +85,10 @@ namespace MLAPIImpl int CreateMLAPITensorInfo(ml_tensors_info_h& tensor_info, inference_engine_layer_property& layer_property); + bool IsFileReadable(const std::string& path); + std::tuple GetNNFWInfo(); + std::string GetModelPath(const std::vector& model_paths); + int mPluginType; int mTargetDevice; ml_single_h mSingle;