FastDeploy  latest
Fast & Easy to Deploy!
utils.h
1 // Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #pragma once
16 
17 #include <cstdio>
18 #include <stdlib.h>
19 
20 #include <fstream>
21 #include <iostream>
22 #include <numeric>
23 #include <sstream>
24 #include <string>
25 #include <type_traits>
26 #include <vector>
27 
28 #ifdef __ANDROID__
29 #include <android/log.h> // NOLINT
30 #endif
31 
32 #if defined(_WIN32)
33 #ifdef FASTDEPLOY_LIB
34 #define FASTDEPLOY_DECL __declspec(dllexport)
35 #else
36 #define FASTDEPLOY_DECL __declspec(dllimport)
37 #endif // FASTDEPLOY_LIB
38 #else
39 #define FASTDEPLOY_DECL __attribute__((visibility("default")))
40 #endif // _WIN32
41 
42 namespace fastdeploy {
43 
44 class FASTDEPLOY_DECL FDLogger {
45  public:
46  static bool enable_info;
47  static bool enable_warning;
48 
49  FDLogger() {
50  line_ = "";
51  prefix_ = "[FastDeploy]";
52  verbose_ = true;
53  }
54  explicit FDLogger(bool verbose, const std::string& prefix = "[FastDeploy]");
55 
56  template <typename T> FDLogger& operator<<(const T& val) {
57  if (!verbose_) {
58  return *this;
59  }
60  std::stringstream ss;
61  ss << val;
62  line_ += ss.str();
63  return *this;
64  }
65 
66  FDLogger& operator<<(std::ostream& (*os)(std::ostream&));
67 
68  ~FDLogger() {
69  if (verbose_ && line_ != "") {
70  std::cout << line_ << std::endl;
71 #ifdef __ANDROID__
72  __android_log_print(ANDROID_LOG_INFO, prefix_.c_str(), "%s",
73  line_.c_str());
74 #endif
75  }
76  }
77 
78  private:
79  std::string line_;
80  std::string prefix_;
81  bool verbose_ = true;
82 };
83 
84 FASTDEPLOY_DECL bool ReadBinaryFromFile(const std::string& file,
85  std::string* contents);
86 
87 #ifndef __REL_FILE__
88 #define __REL_FILE__ __FILE__
89 #endif
90 
91 #define FDERROR \
92  FDLogger(true, "[ERROR]") \
93  << __REL_FILE__ << "(" << __LINE__ << ")::" << __FUNCTION__ << "\t"
94 
95 #define FDWARNING \
96  FDLogger(fastdeploy::FDLogger::enable_warning, "[WARNING]") \
97  << __REL_FILE__ << "(" << __LINE__ << ")::" << __FUNCTION__ << "\t"
98 
99 #define FDINFO \
100  FDLogger(fastdeploy::FDLogger::enable_info, "[INFO]") \
101  << __REL_FILE__ << "(" << __LINE__ \
102  << ")::" << __FUNCTION__ << "\t"
103 
104 #define FDASSERT(condition, format, ...) \
105  if (!(condition)) { \
106  int n = std::snprintf(nullptr, 0, format, ##__VA_ARGS__); \
107  std::vector<char> buffer(n + 1); \
108  std::snprintf(buffer.data(), n + 1, format, ##__VA_ARGS__); \
109  FDERROR << buffer.data() << std::endl; \
110  std::abort(); \
111  }
112 
114 
115 #define FD_PRIVATE_CASE_TYPE_USING_HINT(NAME, enum_type, type, HINT, ...) \
116  case enum_type: { \
117  using HINT = type; \
118  __VA_ARGS__(); \
119  break; \
120  }
121 
122 #define FD_PRIVATE_CASE_TYPE(NAME, enum_type, type, ...) \
123  FD_PRIVATE_CASE_TYPE_USING_HINT(NAME, enum_type, type, data_t, __VA_ARGS__)
124 
125 // Visit different data type to match the corresponding function of FDTensor
126 #define FD_VISIT_ALL_TYPES(TYPE, NAME, ...) \
127  [&] { \
128  const auto& __dtype__ = TYPE; \
129  switch (__dtype__) { \
130  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::UINT8, uint8_t, \
131  __VA_ARGS__) \
132  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::BOOL, bool, \
133  __VA_ARGS__) \
134  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::INT32, int32_t, \
135  __VA_ARGS__) \
136  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::INT64, int64_t, \
137  __VA_ARGS__) \
138  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::FP32, float, \
139  __VA_ARGS__) \
140  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::FP64, double, \
141  __VA_ARGS__) \
142  default: \
143  FDASSERT(false, \
144  "Invalid enum data type. Expect to accept data " \
145  "type BOOL, INT32, " \
146  "INT64, FP32, FP64, but receive type %s.", \
147  Str(__dtype__).c_str()); \
148  } \
149  }()
150 
151 #define FD_VISIT_INT_FLOAT_TYPES(TYPE, NAME, ...) \
152  [&] { \
153  const auto& __dtype__ = TYPE; \
154  switch (__dtype__) { \
155  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::INT32, int32_t, \
156  __VA_ARGS__) \
157  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::INT64, int64_t, \
158  __VA_ARGS__) \
159  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::FP32, float, \
160  __VA_ARGS__) \
161  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::FP64, double, \
162  __VA_ARGS__) \
163  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::UINT8, uint8_t, \
164  __VA_ARGS__) \
165  default: \
166  FDASSERT(false, \
167  "Invalid enum data type. Expect to accept data type INT32, " \
168  "INT64, FP32, FP64, UINT8 but receive type %s.", \
169  Str(__dtype__).c_str()); \
170  } \
171  }()
172 
173 #define FD_VISIT_FLOAT_TYPES(TYPE, NAME, ...) \
174  [&] { \
175  const auto& __dtype__ = TYPE; \
176  switch (__dtype__) { \
177  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::FP32, float, \
178  __VA_ARGS__) \
179  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::FP64, double, \
180  __VA_ARGS__) \
181  default: \
182  FDASSERT(false, \
183  "Invalid enum data type. Expect to accept data type FP32, " \
184  "FP64, but receive type %s.", \
185  Str(__dtype__).c_str()); \
186  } \
187  }()
188 
189 #define FD_VISIT_INT_TYPES(TYPE, NAME, ...) \
190  [&] { \
191  const auto& __dtype__ = TYPE; \
192  switch (__dtype__) { \
193  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::INT32, int32_t, \
194  __VA_ARGS__) \
195  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::INT64, int64_t, \
196  __VA_ARGS__) \
197  FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::UINT8, uint8_t, \
198  __VA_ARGS__) \
199  default: \
200  FDASSERT(false, \
201  "Invalid enum data type. Expect to accept data type INT32, " \
202  "INT64, UINT8 but receive type %s.", \
203  Str(__dtype__).c_str()); \
204  } \
205  }()
206 
207 FASTDEPLOY_DECL std::vector<int64_t>
208 GetStride(const std::vector<int64_t>& dims);
209 
210 template <typename T>
211 std::string Str(const std::vector<T>& shape) {
212  std::ostringstream oss;
213  oss << "[ " << shape[0];
214  for (size_t i = 1; i < shape.size(); ++i) {
215  oss << " ," << shape[i];
216  }
217  oss << " ]";
218  return oss.str();
219 }
220 
222 FASTDEPLOY_DECL void SetLogger(bool enable_info = true,
223  bool enable_warning = true);
224 
225 template <typename T>
226 void CalculateStatisInfo(const void* src_ptr, int size, double* mean,
227  double* max, double* min) {
228  const T* ptr = static_cast<const T*>(src_ptr);
229  *mean = static_cast<double>(0);
230  *max = static_cast<double>(-99999999);
231  *min = static_cast<double>(99999999);
232  for (int i = 0; i < size; ++i) {
233  if (*(ptr + i) > *max) {
234  *max = *(ptr + i);
235  }
236  if (*(ptr + i) < *min) {
237  *min = *(ptr + i);
238  }
239  *mean += *(ptr + i);
240  }
241  *mean = *mean / size;
242 }
243 
244 
245 } // namespace fastdeploy
fastdeploy::SetLogger
void SetLogger(bool enable_info, bool enable_warning)
Set behaviour of logging while using FastDeploy.
Definition: utils.cc:24
fastdeploy
All C++ FastDeploy APIs are defined inside this namespace.
Definition: option.h:16
Generated by   doxygen 1.8.13