onnxruntime

1
// Copyright (c) Microsoft Corporation. All rights reserved.
2
// Licensed under the MIT License.
3

4
#include "testPch.h"
5
#include "RawApiTests.h"
6
#include "RawApiHelpers.h"
7

8
#include <fstream>
9

10
#include <roapi.h>
11

12
namespace ml = Microsoft::AI::MachineLearning;
13

14
auto CreateModelAsBuffer(const wchar_t* model_path) {
15
  std::ifstream input_stream(model_path, std::ios::binary | std::ios::ate);
16
  std::streamsize size = input_stream.tellg();
17
  input_stream.seekg(0, std::ios::beg);
18

19
  std::vector<char> buffer(static_cast<std::vector<char>::size_type>(size));
20
  input_stream.read(buffer.data(), size);
21

22
  return std::make_pair(buffer, size);
23
}
24

25
static void RawApiTestsApiTestsClassSetup() {
26
  WINML_EXPECT_HRESULT_SUCCEEDED(RoInitialize(RO_INIT_TYPE::RO_INIT_MULTITHREADED));
27
}
28

29
static void CreateModelFromFilePath() {
30
  std::wstring model_path = L"model.onnx";
31
  std::unique_ptr<ml::learning_model> model = nullptr;
32
  WINML_EXPECT_NO_THROW(model = std::make_unique<ml::learning_model>(model_path.c_str(), model_path.size()));
33
  WINML_EXPECT_NO_THROW(model.reset());
34
}
35

36
static void CreateCpuDevice() {
37
  std::unique_ptr<ml::learning_model_device> device = nullptr;
38
  WINML_EXPECT_NO_THROW(device = std::make_unique<ml::learning_model_device>());
39
}
40

41
static void Evaluate() {
42
  std::wstring model_path = L"model.onnx";
43
  std::unique_ptr<ml::learning_model> model = nullptr;
44
  WINML_EXPECT_NO_THROW(model = std::make_unique<ml::learning_model>(model_path.c_str(), model_path.size()));
45

46
  std::unique_ptr<ml::learning_model_device> device = nullptr;
47
  WINML_EXPECT_NO_THROW(device = std::make_unique<ml::learning_model_device>());
48

49
  RunOnDevice(*model.get(), *device.get(), InputStrategy::CopyInputs);
50

51
  WINML_EXPECT_NO_THROW(model.reset());
52
}
53

54
static void EvaluateNoInputCopy() {
55
  std::wstring model_path = L"model.onnx";
56
  std::unique_ptr<ml::learning_model> model = nullptr;
57
  WINML_EXPECT_NO_THROW(model = std::make_unique<ml::learning_model>(model_path.c_str(), model_path.size()));
58

59
  std::unique_ptr<ml::learning_model_device> device = nullptr;
60
  WINML_EXPECT_NO_THROW(device = std::make_unique<ml::learning_model_device>());
61

62
  RunOnDevice(*model.get(), *device.get(), InputStrategy::BindAsReference);
63

64
  WINML_EXPECT_NO_THROW(model.reset());
65
}
66

67
static void EvaluateManyBuffers() {
68
  std::wstring model_path = L"model.onnx";
69
  std::unique_ptr<ml::learning_model> model = nullptr;
70
  WINML_EXPECT_NO_THROW(model = std::make_unique<ml::learning_model>(model_path.c_str(), model_path.size()));
71

72
  std::unique_ptr<ml::learning_model_device> device = nullptr;
73
  WINML_EXPECT_NO_THROW(device = std::make_unique<ml::learning_model_device>());
74

75
  RunOnDevice(*model.get(), *device.get(), InputStrategy::BindWithMultipleReferences);
76

77
  WINML_EXPECT_NO_THROW(model.reset());
78
}
79

80
static void EvaluateFromModelFromBuffer() {
81
  std::wstring model_path = L"model.onnx";
82

83
  auto [buffer, size] = CreateModelAsBuffer(model_path.c_str());
84

85
  std::unique_ptr<ml::learning_model> model = nullptr;
86
  WINML_EXPECT_NO_THROW(model = std::make_unique<ml::learning_model>(buffer.data(), static_cast<size_t>(size)));
87

88
  std::unique_ptr<ml::learning_model_device> device = nullptr;
89
  WINML_EXPECT_NO_THROW(device = std::make_unique<ml::learning_model_device>());
90

91
  RunOnDevice(*model.get(), *device.get(), InputStrategy::CopyInputs);
92

93
  WINML_EXPECT_NO_THROW(model.reset());
94
}
95

96
const RawApiTestsApi& getapi() {
97
  static constexpr RawApiTestsApi api = {
98
    RawApiTestsApiTestsClassSetup,
99
    CreateModelFromFilePath,
100
    CreateCpuDevice,
101
    Evaluate,
102
    EvaluateNoInputCopy,
103
    EvaluateManyBuffers,
104
    EvaluateFromModelFromBuffer,
105
  };
106
  return api;
107
}
108