-
-
Notifications
You must be signed in to change notification settings - Fork 16
/
ErrorHandling.h
204 lines (164 loc) · 7.57 KB
/
ErrorHandling.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
// Reusable error handling primitives for Vulkan
#ifndef COMMON_ERROR_HANDLING_H
#define COMMON_ERROR_HANDLING_H
#include <iostream>
#include <string>
#include <sstream>
#include <vulkan/vulkan.h>
#include "VulkanIntrospection.h"
struct VulkanResultException{
const char* file;
unsigned line;
const char* func;
const char* source;
VkResult result;
VulkanResultException( const char* file, unsigned line, const char* func, const char* source, VkResult result )
: file( file ), line( line ), func( func ), source( source ), result( result ){}
};
#define RESULT_HANDLER( errorCode, source ) if( errorCode ) throw VulkanResultException( __FILE__, __LINE__, __func__, source, errorCode )
#define RESULT_HANDLER_EX( cond, errorCode, source ) if( cond ) throw VulkanResultException( __FILE__, __LINE__, __func__, source, errorCode )
#define RUNTIME_ASSERT( cond, source ) if( !(cond) ) throw source " failed";
// just use cout for logging now
std::ostream& logger = std::cout;
enum Highlight{ highlightOff = 0, highlightOn };
void genericDebugCallback( std::string flags, Highlight highlight, std::string msgCode, std::string object, const char* message );
VKAPI_ATTR VkBool32 VKAPI_CALL genericDebugReportCallback(
VkDebugReportFlagsEXT msgFlags,
VkDebugReportObjectTypeEXT objType,
uint64_t srcObject,
size_t /*location*/,
int32_t msgCode,
const char* pLayerPrefix,
const char* pMsg,
void* /*pUserData*/
);
VKAPI_ATTR VkBool32 VKAPI_CALL genericDebugUtilsCallback(
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
VkDebugUtilsMessageTypeFlagsEXT messageTypes,
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
void* /*pUserData*/
);
struct DebugObjectVariant{
enum DebugObjectTag{ debugReportType, debugUtilsType } tag;
union{
VkDebugReportCallbackEXT debugReportCallback;
VkDebugUtilsMessengerEXT debugUtilsMessenger;
};
};
DebugObjectVariant initDebug( const VkInstance instance, const DebugObjectVariant::DebugObjectTag debugExtension, const VkDebugUtilsMessageSeverityFlagsEXT debugSeverity, const VkDebugUtilsMessageTypeFlagsEXT debugType );
void killDebug( VkInstance instance, DebugObjectVariant debug );
VkDebugReportFlagsEXT translateFlags( const VkDebugUtilsMessageSeverityFlagsEXT debugSeverity, const VkDebugUtilsMessageTypeFlagsEXT debugType );
// Implementation
//////////////////////////////////
void genericDebugCallback( std::string flags, Highlight highlight, std::string msgCode, std::string object, const char* message ){
using std::endl;
using std::string;
const string report = flags + ": " + object + ": " + msgCode + ", \"" + message + '"';
if( highlight ){
const string border( 80, '!' );
logger << border << endl;
logger << report << endl;
logger << border << endl << endl;
}
else{
logger << report << endl;
}
}
VKAPI_ATTR VkBool32 VKAPI_CALL genericDebugReportCallback(
VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objectType,
uint64_t object,
size_t /*location*/,
int32_t messageCode,
const char* pLayerPrefix,
const char* pMessage,
void* /*pUserData*/
){
using std::to_string;
using std::string;
Highlight highlight;
if( (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) || (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) || (flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) ){
highlight = highlightOn;
}
else highlight = highlightOff;
genericDebugCallback( dbrflags_to_string( flags ), highlight, string(pLayerPrefix) + ", " + to_string( messageCode ), to_string( objectType ) + "(" + to_string_hex( object ) + ")", pMessage );
return VK_FALSE; // no abort on misbehaving command
}
VKAPI_ATTR VkBool32 VKAPI_CALL genericDebugUtilsCallback(
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
VkDebugUtilsMessageTypeFlagsEXT messageTypes,
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
void* /*pUserData*/
){
using std::to_string;
using std::string;
Highlight highlight;
if( (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) || (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT)){
highlight = highlightOn;
}
else highlight = highlightOff;
string objects;
bool first = true;
for( uint32_t i = 0; i < pCallbackData->objectCount; ++i ){
const auto& obj = pCallbackData->pObjects[i];
if( first ) first = false;
else objects += ", ";
objects += to_string( obj.objectType ) + "(" + to_string_hex( obj.objectHandle ) + ")";
}
objects = "[" + objects + "]";
genericDebugCallback( dbutype_to_string( messageTypes ) + "+" + to_string( messageSeverity ), highlight, string(pCallbackData->pMessageIdName) + "(" + to_string( pCallbackData->messageIdNumber ) + ")", objects, pCallbackData->pMessage );
return VK_FALSE; // no abort on misbehaving command
}
VkDebugReportFlagsEXT translateFlags( const VkDebugUtilsMessageSeverityFlagsEXT debugSeverity, const VkDebugUtilsMessageTypeFlagsEXT debugType ){
VkDebugReportFlagsEXT flags = 0;
if( (debugType & VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT) || (debugType & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) ){
if( debugSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT ) flags |= VK_DEBUG_REPORT_ERROR_BIT_EXT;
if( debugSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT ) flags |= VK_DEBUG_REPORT_WARNING_BIT_EXT;
if( (debugSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) && (debugType & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) ) flags |= VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
if( debugSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT ) flags |= VK_DEBUG_REPORT_INFORMATION_BIT_EXT;
if( debugSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT ) flags |= VK_DEBUG_REPORT_DEBUG_BIT_EXT;
}
return flags;
}
DebugObjectVariant initDebug( const VkInstance instance, const DebugObjectVariant::DebugObjectTag debugExtension, const VkDebugUtilsMessageSeverityFlagsEXT debugSeverity, const VkDebugUtilsMessageTypeFlagsEXT debugType ){
DebugObjectVariant debug;
debug.tag = debugExtension;
if( debugExtension == DebugObjectVariant::debugUtilsType ){
const VkDebugUtilsMessengerCreateInfoEXT dmci = {
VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
nullptr, // pNext
0, // flags
debugSeverity,
debugType,
::genericDebugUtilsCallback,
nullptr // pUserData
};
const VkResult errorCode = vkCreateDebugUtilsMessengerEXT( instance, &dmci, nullptr, &debug.debugUtilsMessenger ); RESULT_HANDLER( errorCode, "vkCreateDebugUtilsMessengerEXT" );
}
else if( debugExtension == DebugObjectVariant::debugReportType ){
const VkDebugReportCallbackCreateInfoEXT debugCreateInfo{
VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
nullptr, // pNext
translateFlags( debugSeverity, debugType ),
::genericDebugReportCallback,
nullptr // pUserData
};
const VkResult errorCode = vkCreateDebugReportCallbackEXT( instance, &debugCreateInfo, nullptr, &debug.debugReportCallback ); RESULT_HANDLER( errorCode, "vkCreateDebugReportCallbackEXT" );
}
else{
throw "initDebug: unknown debug extension";
}
return debug;
}
void killDebug( const VkInstance instance, const DebugObjectVariant debug ){
if( debug.tag == DebugObjectVariant::debugUtilsType ){
vkDestroyDebugUtilsMessengerEXT( instance, debug.debugUtilsMessenger, nullptr );
}
else if( debug.tag == DebugObjectVariant::debugReportType ){
vkDestroyDebugReportCallbackEXT( instance, debug.debugReportCallback, nullptr );
}
else{
throw "initDebug: unknown debug extension";
}
}
#endif //COMMON_ERROR_HANDLING_H