Merge branch 'main' into shama/csharp_sample_update

Author: shamaksx

c_cxx/MNIST/MNIST.cpp

@@ -40,7 +40,8 @@ struct MNIST {
     const char* input_names[] = {"Input3"};
     const char* output_names[] = {"Plus214_Output_0"};
 
-    session_.Run(Ort::RunOptions{nullptr}, input_names, &input_tensor_, 1, output_names, &output_tensor_, 1);
+    Ort::RunOptions run_options;
+    session_.Run(run_options, input_names, &input_tensor_, 1, output_names, &output_tensor_, 1);
     softmax(results_);
     result_ = std::distance(results_.begin(), std::max_element(results_.begin(), results_.end()));
     return result_;

c_cxx/README.md

@@ -12,9 +12,7 @@ This directory contains a few C/C++ sample applications for demoing onnxruntime
 ## Prerequisites
 1. Visual Studio 2015/2017/2019
 2. cmake(version >=3.13)
-3. (optional) [libpng 1.6](http://www.libpng.org/pub/png/libpng.html)
-
-You may get a precompiled libpng library from [https://onnxruntimetestdata.blob.core.windows.net/models/libpng.zip](https://onnxruntimetestdata.blob.core.windows.net/models/libpng.zip)
+3. (optional) [libpng 1.6](https://libpng.sourceforge.io/)
 
 ## Install ONNX Runtime
 ### Option 1: download a prebuilt package
@@ -31,16 +29,16 @@ build.bat --config RelWithDebInfo --build_shared_lib --parallel
 By default this will build a project with "C:\Program Files (x86)\onnxruntime" install destination. This is a protected folder on Windows. If you do not want to run installation with elevated priviliges you will need to override the default installation location by passing extra CMake arguments. For example:
 
 ```
-build.bat --config RelWithDebInfo --build_shared_lib --parallel  --cmake_extra_defines CMAKE_INSTALL_PREFIX=c:\dev\ort_install
+build.bat --config RelWithDebInfo --build_dir .\build  --build_shared_lib --parallel  --cmake_extra_defines CMAKE_INSTALL_PREFIX=c:\dev\ort_install
 ```
 
-By default products of the build on Windows go to .\build\Windows\<config> folder. In the case above it would be .\build\Windows\RelWithDebInfo.
+By default products of the build on Windows go to .\build\Windows\<config> folder. In the case above it would be .\build\RelWithDebInfo since the build folder is mentioned explicitly.
 If you did not specify alternative installation location above you would need to open an elevated command prompt to install onnxruntime.
 Run the following commands.
 
 ```
-cd .\Windows\RelWithDebInfo
-msbuild INSTALL.vcxproj /p:Configuration=RelWithDebInfo
+cmake --install .\build\RelWithDebInfo --config RelWithDebInfo
+
 ```
 
 ## Build the samples
@@ -63,6 +61,7 @@ Or build it using msbuild
 
 ```bat
 msbuild onnxruntime_samples.sln /p:Configuration=Debug|Release
+cmake --install .\build\Debug|Release --config Debug
 ```
 
 To run the samples make sure that your Install Folder Bin is in the path so your sample executable can find onnxruntime dll and libpng if you used it.

c_cxx/Snpe_EP/CMakeLists.txt

@@ -16,7 +16,13 @@ ADD_EXECUTABLE(snpe_ep_sample  main.cpp)
 if(HAVE_TENSORRT_PROVIDER_FACTORY_H)
   target_compile_definitions(snpe_ep_sample PRIVATE -DHAVE_TENSORRT_PROVIDER_FACTORY_H)
 endif()
-target_link_libraries(snpe_ep_sample onnxruntime)
+
+set(ORT_LIBS onnxruntime)
+if(ANDROID)
+list(APPEND ORT_LIBS libc++_shared.so)
+endif()
+target_link_libraries(snpe_ep_sample ${ORT_LIBS})
+
 if(MSVC)
   target_link_directories(snpe_ep_sample PRIVATE ${ONNXRUNTIME_ROOTDIR}/build/Windows/Release/Release)
 else()

c_cxx/Snpe_EP/README.md

@@ -47,8 +47,8 @@
     std::vector<const char*> options_keys = {"runtime", "buffer_type"};
     std::vector<const char*> options_values = {"CPU", "TF8"}; // set to TF8 if use quantized data
 
-    CheckStatus(g_ort, g_ort->SessionOptionsAppendExecutionProvider_SNPE(session_options, options_keys.data(),
-                                                                       options_values.data(), options_keys.size()));
+    g_ort->SessionOptionsAppendExecutionProvider(session_options, "SNPE", options_keys.data(),
+                                                 options_values.data(), options_keys.size());
     ```
     Please refers to the unit test case [Snpe_ConvertFromAbs.QuantizedModelTf8Test](https://github.com/microsoft/onnxruntime/blob/5ecfaef042380995fb15587ccf6ff77f9d3a01d2/onnxruntime/test/contrib_ops/snpe_op_test.cc#L209-L251) for more details.
 
@@ -74,7 +74,12 @@
     chairs.raw -- from $SNPE_ROOT/models/inception_v3/data/cropped
     imagenet_slim_labels.txt -- from $SNPE_ROOT/models/inception_v3/data
 
-    Run snpe_ep_sample.exe, it will output:
+    Run
+    ```
+    snpe_ep_sample.exe --cpu chairs.raw
+    ```
+
+    it will output:
 
     ```
     832, 0.299591, studio couch
@@ -103,6 +108,7 @@
     adb push [$SNPE_ROOT]/lib/dsp/*.so /data/local/tmp/snpeexample
     adb push [$Onnxruntime_ROOT]/build/Android/Release/libonnxruntime.so /data/local/tmp/snpeexample    
     adb push [$SNPE_ROOT]/models/inception_v3/data/cropped/chairs.raw /data/local/tmp/snpeexample
+    adb push [$SNPE_ROOT]/models/inception_v3/data/imagenet_slim_labels.txt /data/local/tmp/snpeexample
     adb push [$SNPE_ROOT]/models/inception_v3/snpe_inception_v3.onnx /data/local/tmp/snpeexample
     adb push ./onnxruntime-inference-examples/c_cxx/Snpe_EP/build_android/snpe_ep_sample /data/local/tmp/snpeexample
     ```
@@ -115,7 +121,8 @@
     chmod +x *
     export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/local/tmp/snpeexample
     export PATH=$PATH:/data/local/tmp/snpeexample
-    snpe_ep_sample
+    snpe_ep_sample --cpu chairs.raw
+    snpe_ep_sample --dsp chairs.raw
     ```
 
     it will output:

c_cxx/Snpe_EP/main.cpp

@@ -16,12 +16,12 @@ bool CheckStatus(const OrtApi* g_ort, OrtStatus* status) {
     const char* msg = g_ort->GetErrorMessage(status);
     std::cerr << msg << std::endl;
     g_ort->ReleaseStatus(status);
-    throw std::exception();
+    throw Ort::Exception(msg, OrtErrorCode::ORT_EP_FAIL);
   }
   return true;
 }
 
-void run_ort_snpe_ep() {
+void run_ort_snpe_ep(std::string backend, std::string input_path) {
 #ifdef _WIN32
   const wchar_t* model_path = L"snpe_inception_v3.onnx";
 #else
@@ -38,10 +38,10 @@ void run_ort_snpe_ep() {
   CheckStatus(g_ort, g_ort->SetSessionGraphOptimizationLevel(session_options, ORT_ENABLE_BASIC));
 
   std::vector<const char*> options_keys = {"runtime", "buffer_type"};
-  std::vector<const char*> options_values = {"CPU", "FLOAT"}; // set to TF8 if use quantized data
+  std::vector<const char*> options_values = {backend.c_str(), "FLOAT"};  // set to TF8 if use quantized data
 
-  CheckStatus(g_ort, g_ort->SessionOptionsAppendExecutionProvider_SNPE(session_options, options_keys.data(),
-                                                                       options_values.data(), options_keys.size()));
+  CheckStatus(g_ort, g_ort->SessionOptionsAppendExecutionProvider(session_options, "SNPE", options_keys.data(),
+                                                                  options_values.data(), options_keys.size()));
   OrtSession* session;
   CheckStatus(g_ort, g_ort->CreateSession(env, model_path, session_options, &session));
 
@@ -124,7 +124,7 @@ void run_ort_snpe_ep() {
   size_t input_data_length = input_data_size * sizeof(float);
   std::vector<float> input_data(input_data_size, 1.0);
 
-  std::ifstream input_raw_file("chairs.raw", std::ios::binary);
+  std::ifstream input_raw_file(input_path, std::ios::binary);
   input_raw_file.seekg(0, std::ios::end);
   const size_t num_elements = input_raw_file.tellg() / sizeof(float);
   input_raw_file.seekg(0, std::ios::beg);
@@ -162,7 +162,35 @@ void run_ort_snpe_ep() {
   printf("%d, %f, %s \n", max_index, *max, label_table[max_index].c_str());
 }
 
+void PrintHelp() {
+  std::cout << "To run the sample, use the following command:" << std::endl;
+  std::cout << "Example: ./snpe_ep_sample --cpu <path_to_raw_input>" << std::endl;
+  std::cout << "To Run with SNPE CPU backend. Example: ./snpe_ep_sample --cpu chairs.raw" << std::endl;
+  std::cout << "To Run with SNPE DSP backend. Example: ./snpe_ep_sample --dsp chairs.raw" << std::endl;
+}
+
+constexpr const char* CPUBACKEDN = "--cpu";
+constexpr const char* DSPBACKEDN = "--dsp";
+
 int main(int argc, char* argv[]) {
-  run_ort_snpe_ep(); 
+  std::string backend = "CPU";
+
+  if (argc != 3) {
+    PrintHelp();
+    return 1;
+  }
+
+  if (strcmp(argv[1], CPUBACKEDN) == 0) {
+    backend = "CPU";
+  } else if (strcmp(argv[1], DSPBACKEDN) == 0) {
+    backend = "DSP";
+  } else {
+    std::cout << "This sample only support CPU, DSP." << std::endl;
+    PrintHelp();
+    return 1;
+  }
+  std::string input_path(argv[2]);
+
+  run_ort_snpe_ep(backend, input_path);
   return 0;
 }

c_cxx/imagenet/CMakeLists.txt

@@ -2,6 +2,7 @@
 # Licensed under the MIT License.
 
 set(FS_SOURCES local_filesystem.h sync_api.h controller.h controller.cc)
+
 if(WIN32)
   LIST(APPEND FS_SOURCES local_filesystem_win.cc sync_api_win.cc)
 else()
@@ -17,17 +18,22 @@ if(JPEG_FOUND)
 elseif(WIN32)
   SET(IMAGE_SRC image_loader_wic.cc)
 endif()
+
 add_executable(image_classifier main.cc runnable_task.h data_processing.h ${IMAGE_SRC}
-        async_ring_buffer.h image_loader.cc image_loader.h cached_interpolation.h  single_consumer.h)
+        async_ring_buffer.h image_loader.cc image_loader.h cached_interpolation.h single_consumer.h)
+        
 if(JPEG_FOUND)
   target_compile_definitions(image_classifier PRIVATE HAVE_JPEG)
   SET(IMAGE_HEADERS ${JPEG_INCLUDE_DIR})
   SET(IMAGE_LIBS ${JPEG_LIBRARIES})
 endif()
+
 target_include_directories(image_classifier PRIVATE ${PROJECT_SOURCE_DIR}/include ${IMAGE_HEADERS})
+
 if(WIN32)
   target_compile_definitions(image_classifier PRIVATE WIN32_LEAN_AND_MEAN NOMINMAX)
 endif()
+
 target_link_libraries(image_classifier PRIVATE onnxruntime slim_fs_lib ${IMAGE_LIBS})
 
 

c_cxx/imagenet/image_loader.h

@@ -8,7 +8,7 @@
 #include "cached_interpolation.h"
 #include "sync_api.h"
 #include "data_processing.h"
-#include <onnxruntime_c_api.h>
+#include <onnxruntime_cxx_api.h>
 
 template <typename T>
 void ResizeImageInMemory(const T* input_data, float* output_data, int in_height, int in_width, int out_height,

c_cxx/imagenet/local_filesystem.h

@@ -19,6 +19,7 @@
 #include <unistd.h>
 #include <sys/mman.h>
 #endif
+
 #include <onnxruntime_c_api.h>
 void ReadFileAsString(const ORTCHAR_T* fname, void*& p, size_t& len);
 

c_cxx/imagenet/main.cc

@@ -12,10 +12,11 @@
 #include <vector>
 #include <memory>
 #include <atomic>
+#include <optional>
 
-#include "providers.h"
-#include "local_filesystem.h"
-#include "sync_api.h"
+ #include "providers.h"
+ #include "local_filesystem.h"
+ #include "sync_api.h"
 
 #include <onnxruntime_cxx_api.h>
 
@@ -26,8 +27,10 @@
 #ifdef _WIN32
 #include <atlbase.h>
 #endif
+
 using namespace std::chrono;
 
+
 class Validator : public OutputCollector<TCharString> {
  private:
   static std::vector<std::string> ReadFileToVec(const TCharString& file_path, size_t expected_line_count) {
@@ -81,20 +84,15 @@ class Validator : public OutputCollector<TCharString> {
   int image_size_;
 
   std::mutex m_;
-  char* input_name_ = nullptr;
-  char* output_name_ = nullptr;
+  std::optional<Ort::AllocatedStringPtr> input_name_;
+  std::optional<Ort::AllocatedStringPtr> output_name_;
   Ort::Env& env_;
   const TCharString model_path_;
   system_clock::time_point start_time_;
 
  public:
   int GetImageSize() const { return image_size_; }
 
-  ~Validator() {
-    free(input_name_);
-    free(output_name_);
-  }
-
   void PrintResult() {
     if (finished_count_ == 0) return;
     printf("Top-1 Accuracy %f\n", ((float)top_1_correct_count_.load() / finished_count_));
@@ -124,20 +122,15 @@ class Validator : public OutputCollector<TCharString> {
     VerifyInputOutputCount(session_);
     Ort::AllocatorWithDefaultOptions ort_alloc;
     {
-      char* t = session_.GetInputName(0, ort_alloc);
-      input_name_ = my_strdup(t);
-      ort_alloc.Free(t);
-      t = session_.GetOutputName(0, ort_alloc);
-      output_name_ = my_strdup(t);
-      ort_alloc.Free(t);
+      input_name_.emplace(session_.GetInputNameAllocated(0, ort_alloc));
+      output_name_.emplace(session_.GetOutputNameAllocated(0, ort_alloc));
     }
 
     Ort::TypeInfo info = session_.GetInputTypeInfo(0);
     auto tensor_info = info.GetTensorTypeAndShapeInfo();
     size_t dim_count = tensor_info.GetDimensionsCount();
     assert(dim_count == 4);
-    std::vector<int64_t> dims(dim_count);
-    tensor_info.GetDimensions(dims.data(), dims.size());
+    std::vector<int64_t> dims = tensor_info.GetShape();
     if (dims[1] != dims[2] || dims[3] != 3) {
       throw std::runtime_error("This model is not supported by this program. input tensor need be in NHWC format");
     }
@@ -150,8 +143,10 @@ class Validator : public OutputCollector<TCharString> {
     {
       std::lock_guard<std::mutex> l(m_);
       const size_t remain = task_id_list.size();
+      const char* input_names[] = {input_name_->get()};
+      char* output_names[] = {output_name_->get()};
       Ort::Value output_tensor{nullptr};
-      session_.Run(Ort::RunOptions{nullptr}, &input_name_, &input_tensor, 1, &output_name_, &output_tensor, 1);
+      session_.Run(Ort::RunOptions{nullptr}, input_names, &input_tensor, 1, output_names, &output_tensor, 1);
       float* probs = output_tensor.GetTensorMutableData<float>();
       for (const auto& s : task_id_list) {
         float* end = probs + output_class_count_;

c_cxx/imagenet/sync_api.h

@@ -8,8 +8,6 @@
 #else
 #include <vector>
 #endif
-#include <onnxruntime_c_api.h>
-#include <onnxruntime_cxx_api.h>
 
 #ifdef _WIN32
 #define my_strtol wcstol