1 //
2 // Copyright © 2017 Arm Ltd. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5 #pragma once
6
7 #include <sstream>
8 #include <stdexcept>
9 #include <string>
10
11 namespace armnn
12 {
13
14 struct CheckLocation
15 {
16 const char* m_Function;
17 const char* m_File;
18 unsigned int m_Line;
19
CheckLocationarmnn::CheckLocation20 CheckLocation(const char* func,
21 const char* file,
22 unsigned int line)
23 : m_Function{func}
24 , m_File{file}
25 , m_Line{line}
26 {
27 }
28
AsStringarmnn::CheckLocation29 std::string AsString() const
30 {
31 std::stringstream ss;
32 ss << " at function " << m_Function
33 << " [" << m_File << ':' << m_Line << "]";
34 return ss.str();
35 }
36
FileLinearmnn::CheckLocation37 std::string FileLine() const
38 {
39 std::stringstream ss;
40 ss << " [" << m_File << ':' << m_Line << "]";
41 return ss.str();
42 }
43 };
44
45 /// Base class for all ArmNN exceptions so that users can filter to just those.
46 class Exception : public std::exception
47 {
48 public:
49 explicit Exception(const std::string& message);
50
51 /// exception with context
52 explicit Exception(const std::string& message,
53 const CheckLocation& location);
54
55 /// preserving previous exception context
56 /// and adding local context information
57 explicit Exception(const Exception& other,
58 const std::string& message,
59 const CheckLocation& location);
60
61 virtual const char* what() const noexcept override;
62
63 private:
64 std::string m_Message;
65 };
66
67 /// Class for non-fatal exceptions raised while initialising a backend
68 class BackendUnavailableException : public Exception
69 {
70 public:
71 using Exception::Exception;
72 };
73
74 class ClRuntimeUnavailableException : public BackendUnavailableException
75 {
76 public:
77 using BackendUnavailableException::BackendUnavailableException;
78 };
79
80 class InvalidArgumentException : public Exception
81 {
82 public:
83 using Exception::Exception;
84 };
85
86 class FileNotFoundException : public Exception
87 {
88 public:
89 using Exception::Exception;
90 };
91
92 class ParseException : public Exception
93 {
94 public:
95 using Exception::Exception;
96 };
97
98 class UnimplementedException : public Exception
99 {
100 public:
101 using Exception::Exception;
102 UnimplementedException();
103 };
104
105 class LayerValidationException : public Exception
106 {
107 using Exception::Exception;
108 };
109
110 class GraphValidationException : public Exception
111 {
112 using Exception::Exception;
113 };
114
115 class BadOptionalAccessException : public Exception
116 {
117 using Exception::Exception;
118 };
119
120 class RuntimeException : public Exception
121 {
122 using Exception::Exception;
123 };
124
125 class MemoryImportException : public Exception
126 {
127 using Exception::Exception;
128 };
129
130 class MemoryExportException : public Exception
131 {
132 using Exception::Exception;
133 };
134
135 class TimeoutException : public Exception
136 {
137 using Exception::Exception;
138 };
139
140 class PolymorphicDowncastException : public Exception
141 {
142 public:
143 using Exception::Exception;
144 };
145
146 class NullPointerException : public Exception
147 {
148 public:
149 using Exception::Exception;
150 };
151
152 class BackendCapabilityException : public Exception
153 {
154 public:
155 using Exception::Exception;
156 };
157
158 class MemoryValidationException : public Exception
159 {
160 public:
161 using Exception::Exception;
162 };
163
164 template <typename ExceptionType>
ConditionalThrow(bool condition,const std::string & message)165 void ConditionalThrow(bool condition, const std::string& message)
166 {
167 if (!condition)
168 {
169 throw ExceptionType(message);
170 }
171 }
172
173 template <typename ExceptionType>
ConditionalThrow(bool condition)174 void ConditionalThrow(bool condition)
175 {
176 if (!condition)
177 {
178 throw ExceptionType();
179 }
180 }
181
182
183 ///
184 /// ComparedType must support:
185 /// operator==(const ComparedType&)
186 /// operator<<(ostream&, const ComparedType&)
187 ///
188 template <typename ExceptionType, typename ComparedType>
ConditionalThrowIfNotEqual(const std::string & message,const ComparedType & leftHandSide,const ComparedType & rightHandSide)189 void ConditionalThrowIfNotEqual(const std::string& message,
190 const ComparedType& leftHandSide,
191 const ComparedType& rightHandSide)
192 {
193 if (!(leftHandSide == rightHandSide))
194 {
195 std::stringstream ss;
196 ss << message << " : " << leftHandSide << " != " << rightHandSide;
197 throw ExceptionType(ss.str());
198 }
199 }
200
201 } // namespace armnn
202
203 #define CHECK_LOCATION() armnn::CheckLocation(__func__, __FILE__, __LINE__)
204