Improve error tracking

This would keep track of exactly where the error happened (file and
line), so if someone posts an error, it would be a lot easier to spot
exactly where the error occurred.

Also, it separates errno and VkResult, so I don't have to use awkward
VK_ERROR_* values for errors from pthread or libc.

Signed-off-by: Shahbaz Youssefi <[email protected]>

Author: ShabbyX

Makefile.am

@@ -3,35 +3,36 @@ ACLOCAL_AMFLAGS = -I m4
 EXTRA_DIST = COPYING README.md
 
 bin_PROGRAMS = tut1/tut1
-tut1_tut1_SOURCES = tut1/tut1.c tut1/main.c tut1/tut1.h
+tut1_tut1_SOURCES = tut1/tut1.c tut1/tut1_error.c tut1/main.c tut1/tut1.h tut1/tut1_error.h
 
 bin_PROGRAMS += tut2/tut2
 tut2_tut2_SOURCES = tut2/tut2.c tut2/main.c tut2/tut2.h \
-                    tut1/tut1.c
+                    tut1/tut1.c tut1/tut1_error.c
 
 bin_PROGRAMS += tut3/tut3
 tut3_tut3_SOURCES = tut3/tut3.c tut3/main.c tut3/tut3.h \
-                    tut2/tut2.c tut1/tut1.c
+                    tut2/tut2.c tut1/tut1.c tut1/tut1_error.c
 
 bin_PROGRAMS += tut4/tut4
 tut4_tut4_SOURCES = tut4/tut4.c tut4/main.c tut4/tut4.h \
-                    tut3/tut3.c tut2/tut2.c tut1/tut1.c
+                    tut3/tut3.c tut2/tut2.c tut1/tut1.c tut1/tut1_error.c
 
 bin_PROGRAMS += tut5/tut5
 tut5_tut5_SOURCES = tut5/tut5.c tut5/main.c tut5/tut5.h \
-                    tut2/tut2.c tut1/tut1.c
+                    tut2/tut2.c tut1/tut1.c tut1/tut1_error.c
 
 bin_PROGRAMS += tut6/tut6
 tut6_tut6_SOURCES = tut6/tut6.c tut6/main.c tut6/tut6.h \
-                    tut2/tut2.c tut1/tut1.c
+                    tut2/tut2.c tut1/tut1.c tut1/tut1_error.c
 
 bin_PROGRAMS += tut7/tut7
 tut7_tut7_SOURCES = tut7/tut7.c tut7/tut7_render.c tut7/main.c tut7/tut7.h tut7/tut7_render.h \
-                    tut6/tut6.c tut4/tut4.c tut3/tut3.c tut2/tut2.c tut1/tut1.c
+                    tut6/tut6.c tut4/tut4.c tut3/tut3.c tut2/tut2.c tut1/tut1.c tut1/tut1_error.c
 
 bin_PROGRAMS += tut8/tut8
 tut8_tut8_SOURCES = tut8/tut8.c tut8/tut8_render.c tut8/main.c tut8/tut8.h tut8/tut8_render.h \
-                    tut7/tut7.c tut7/tut7_render.c tut6/tut6.c tut4/tut4.c tut3/tut3.c tut2/tut2.c tut1/tut1.c
+                    tut7/tut7.c tut7/tut7_render.c tut6/tut6.c tut4/tut4.c tut3/tut3.c tut2/tut2.c \
+                    tut1/tut1.c tut1/tut1_error.c
 
 shaderdir = $(datadir)/shaders
 shader_DATA = shaders/tut3.comp.spv \

tut1/main.c

@@ -49,34 +49,34 @@ static void print_surprise(const char *indent, const char *who, const char *what
 
 int main(int argc, char **argv)
 {
-	VkResult res;
+	tut1_error res;
 	int retval = EXIT_FAILURE;
 	VkInstance vk;
 	struct tut1_physical_device devs[MAX_DEVICES];
 	uint32_t dev_count = MAX_DEVICES;
 
 	/* Fire up Vulkan */
 	res = tut1_init(&vk);
-	if (res)
+	if (!tut1_error_is_success(&res))
 	{
-		printf("Could not initialize Vulkan: %s\n", tut1_VkResult_string(res));
+		tut1_error_printf(&res, "Could not initialize Vulkan\n");
 		goto exit_bad_init;
 	}
 
 	printf("Vulkan is in the house.\n");
 
 	/* Take a look at what devices there are */
 	res = tut1_enumerate_devices(vk, devs, &dev_count);
-	if (res < 0)
-	{
-		printf("Could not enumerate devices: %s\n", tut1_VkResult_string(res));
-		goto exit_bad_enumerate;
-	}
-	else if (res == VK_INCOMPLETE)
+	if (tut1_error_is_warning(&res))
 	{
 		print_surprise("", "you've got", "devices", "dream of");
 		printf("I have information on only %"PRIu32" of them:\n", dev_count);
 	}
+	else if (!tut1_error_is_success(&res))
+	{
+		tut1_error_printf(&res, "Could not enumerate devices\n");
+		goto exit_bad_enumerate;
+	}
 	else
 		printf("I detected the following %"PRIu32" device%s:\n", dev_count, dev_count == 1?"":"s");
 

tut1/tut1.c

@@ -19,8 +19,11 @@
 
 #include "tut1.h"
 
-VkResult tut1_init(VkInstance *vk)
+tut1_error tut1_init(VkInstance *vk)
 {
+	tut1_error retval = TUT1_ERROR_NONE;
+	VkResult res;
+
 	/*
 	 * Vulkan is not just for graphics.  As the slogan goes, graphics and computation belong together.  As a
 	 * result, initialization in Vulkan is rather verbose to allow the application to adapt to a wide set of
@@ -83,7 +86,10 @@ VkResult tut1_init(VkInstance *vk)
 	 * embedded systems debugging or logging.  Using custom allocation functions will be explored in a future
 	 * tutorial.
 	 */
-	return vkCreateInstance(&info, NULL, vk);
+	res = vkCreateInstance(&info, NULL, vk);
+	tut1_error_set_vkresult(&retval, res);
+
+	return retval;
 }
 
 void tut1_exit(VkInstance vk)
@@ -99,10 +105,11 @@ void tut1_exit(VkInstance vk)
 	vkDestroyInstance(vk, NULL);
 }
 
-VkResult tut1_enumerate_devices(VkInstance vk, struct tut1_physical_device *devs, uint32_t *count)
+tut1_error tut1_enumerate_devices(VkInstance vk, struct tut1_physical_device *devs, uint32_t *count)
 {
 	VkPhysicalDevice phy_devs[*count];
-	VkResult retval;
+	tut1_error retval = TUT1_ERROR_NONE;
+	VkResult res;
 
 	/*
 	 * A physical device in Vulkan is any actual device with Vulkan capabilities.  For example, a physical GPU is
@@ -119,8 +126,9 @@ VkResult tut1_enumerate_devices(VkInstance vk, struct tut1_physical_device *devs
 	 * can't be _that_ many devices and use a fixed upper bound.  If there are more devices than I foresaw, then
 	 * VK_INCOMPLETE would be returned, stating that the array doesn't contain all that there is.
 	 */
-	retval = vkEnumeratePhysicalDevices(vk, count, phy_devs);
-	if (retval < 0)
+	res = vkEnumeratePhysicalDevices(vk, count, phy_devs);
+	tut1_error_set_vkresult(&retval, res);
+	if (res < 0)
 		goto exit_failed;
 
 	for (uint32_t i = 0; i < *count; ++i)

tut1/tut1.h

@@ -22,8 +22,9 @@
 
 #include <vulkan/vulkan.h>
 #include <stdbool.h>
+#include "tut1_error.h"
 
-VkResult tut1_init(VkInstance *vk);
+tut1_error tut1_init(VkInstance *vk);
 void tut1_exit(VkInstance vk);
 
 #define TUT1_MAX_QUEUE_FAMILY 10
@@ -40,7 +41,7 @@ struct tut1_physical_device
 	bool queue_families_incomplete;
 };
 
-VkResult tut1_enumerate_devices(VkInstance vk, struct tut1_physical_device *devs, uint32_t *count);
+tut1_error tut1_enumerate_devices(VkInstance vk, struct tut1_physical_device *devs, uint32_t *count);
 
 const char *tut1_VkResult_string(VkResult res);
 const char *tut1_VkPhysicalDeviceType_string(VkPhysicalDeviceType type);

tut1/tut1_error.c

@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2016 Shahbaz Youssefi <[email protected]>
+ *
+ * This file is part of Shabi's Vulkan Tutorials.
+ *
+ * Shabi's Vulkan Tutorials is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Shabi's Vulkan Tutorials is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Shabi's Vulkan Tutorials.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include "tut1_error.h"
+#include "tut1.h"	/* TODO: once tut1_VkResult_string is moved here, remove this */
+
+/*
+ * Note: this file handles error tracking and reporting, and has little to do with the tutorials themselves.  The main
+ * purpose here is to track the errors precisely, while keeping the actual tutorials as clean as possible.
+ */
+
+void tut1_error_data_set_vkresult(struct tut1_error_data *error, VkResult vkresult, const char *file, unsigned int line)
+{
+	/* If this is not an error, ignore it */
+	if (vkresult == 0)
+		return;
+
+	/* If error is already set, keep the oldest error, but override warnings */
+	if (error->type != TUT1_ERROR_SUCCESS && !(error->type == TUT1_ERROR_VKRESULT_WARNING && vkresult < 0))
+		return;
+
+	*error = (struct tut1_error_data){
+		.type = vkresult < 0?TUT1_ERROR_VKRESULT:TUT1_ERROR_VKRESULT_WARNING,
+		.vkresult = vkresult,
+		.file = file,
+		.line = line,
+	};
+}
+
+void tut1_error_data_set_errno(struct tut1_error_data *error, int err_no, const char *file, unsigned int line)
+{
+	/* If this is not an error, ignore it */
+	if (err_no == 0)
+		return;
+
+	/* If error is already set, keep the oldest error, but override warnings */
+	if (error->type != TUT1_ERROR_SUCCESS && error->type != TUT1_ERROR_VKRESULT_WARNING)
+		return;
+
+	*error = (struct tut1_error_data){
+		.type = TUT1_ERROR_ERRNO,
+		.err_no = err_no,
+		.file = file,
+		.line = line,
+	};
+}
+
+bool tut1_error_data_merge(struct tut1_error_data *error, struct tut1_error_data *other)
+{
+	/* If this is not an error, ignore it */
+	if (other->type == TUT1_ERROR_SUCCESS)
+		return false;
+
+	/* If error is already set, keep the oldest error, but override warnings */
+	if (error->type != TUT1_ERROR_SUCCESS && !(error->type == TUT1_ERROR_VKRESULT_WARNING && (other->type == TUT1_ERROR_VKRESULT || other->type == TUT1_ERROR_ERRNO)))
+		return false;
+
+	*error = *other;
+	return true;
+}
+
+bool tut1_error_is_success(struct tut1_error *error)
+{
+	return error->error.type == TUT1_ERROR_SUCCESS;
+}
+
+bool tut1_error_is_warning(struct tut1_error *error)
+{
+	return error->error.type == TUT1_ERROR_VKRESULT_WARNING;
+}
+
+bool tut1_error_is_error(struct tut1_error *error)
+{
+	return !tut1_error_is_success(error) && !tut1_error_is_warning(error);
+}
+
+static void print_error(FILE *fout, struct tut1_error_data *error_data, const char *prefix)
+{
+	fprintf(fout, "%s:%u: %s", error_data->file, error_data->line, prefix);
+	switch (error_data->type)
+	{
+	case TUT1_ERROR_VKRESULT_WARNING:
+	case TUT1_ERROR_VKRESULT:
+		fprintf(fout, "%s (VkResult %d)\n", tut1_VkResult_string(error_data->vkresult), error_data->vkresult);
+		break;
+	case TUT1_ERROR_ERRNO:
+		fprintf(fout, "%s (errno %d)\n", strerror(error_data->err_no), error_data->err_no);
+		break;
+	default:
+		fprintf(fout, "<internal error>\n");
+		break;
+	}
+}
+
+void tut1_error_fprintf(FILE *fout, struct tut1_error *error, const char *fmt, ...)
+{
+	/* if no error, don't print anything */
+	if (error->error.type == TUT1_ERROR_SUCCESS)
+		return;
+
+	va_list args;
+	va_start(args, fmt);
+	vfprintf(fout, fmt, args);
+	va_end(args);
+
+	print_error(fout, &error->error, "");
+	if (error->sub_error.type != TUT1_ERROR_SUCCESS)
+		print_error(fout, &error->sub_error, "    Resulting from this error: ");
+}

tut1/tut1_error.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2016 Shahbaz Youssefi <[email protected]>
+ *
+ * This file is part of Shabi's Vulkan Tutorials.
+ *
+ * Shabi's Vulkan Tutorials is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Shabi's Vulkan Tutorials is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Shabi's Vulkan Tutorials.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TUT1_ERROR_H
+#define TUT1_ERROR_H
+
+/*
+ * Note: this file handles error tracking and reporting, and has little to do with the tutorials themselves.  The main
+ * purpose here is to track the errors precisely, while keeping the actual tutorials as clean as possible.
+ */
+
+#include <vulkan/vulkan.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <errno.h>
+
+enum tut1_error_type
+{
+	TUT1_ERROR_SUCCESS = 0,
+	TUT1_ERROR_VKRESULT,
+	TUT1_ERROR_VKRESULT_WARNING,	/* VK_INCOMPLETE for example */
+	TUT1_ERROR_ERRNO,
+};
+
+struct tut1_error_data
+{
+	enum tut1_error_type type;
+	union {
+		VkResult vkresult;
+		int err_no;
+	};
+	const char *file;
+	unsigned int line;
+} tut1_error_data;
+
+typedef struct tut1_error
+{
+	struct tut1_error_data error;
+	struct tut1_error_data sub_error;	/*
+						 * Used in cases where error is e.g. "VK_INCOMPLETE", and it is due to
+						 * another error.
+						 */
+} tut1_error;
+
+#define TUT1_ERROR_NONE (struct tut1_error){ .error = { .type = TUT1_ERROR_SUCCESS, }, .sub_error = { .type = TUT1_ERROR_SUCCESS, }, }
+
+#define tut1_error_set_vkresult(es, e)     tut1_error_data_set_vkresult(&(es)->error,     (e), __FILE__, __LINE__)
+#define tut1_error_set_errno(es, e)        tut1_error_data_set_errno   (&(es)->error,     (e), __FILE__, __LINE__)
+#define tut1_error_sub_set_vkresult(es, e) tut1_error_data_set_vkresult(&(es)->sub_error, (e), __FILE__, __LINE__)
+#define tut1_error_sub_set_errno(es, e)    tut1_error_data_set_errno   (&(es)->sub_error, (e), __FILE__, __LINE__)
+#define tut1_error_merge(es, os)                                \
+do {                                                            \
+	if (tut1_error_data_merge(&(es)->error, &(os)->error))  \
+		(es)->sub_error = (os)->sub_error;              \
+} while (0)
+#define tut1_error_sub_merge(es, os)       tut1_error_data_merge(&(es)->sub_error, &(os)->error)
+
+void tut1_error_data_set_vkresult(struct tut1_error_data *error, VkResult vkresult, const char *file, unsigned int line);
+void tut1_error_data_set_errno(struct tut1_error_data *error, int err_no, const char *file, unsigned int line);
+bool tut1_error_data_merge(struct tut1_error_data *error, struct tut1_error_data *other);
+
+bool tut1_error_is_success(struct tut1_error *error);
+bool tut1_error_is_warning(struct tut1_error *error);
+bool tut1_error_is_error(struct tut1_error *error);
+#define tut1_error_printf(es, ...) tut1_error_fprintf(stdout, (es), __VA_ARGS__)
+void tut1_error_fprintf(FILE *fout, struct tut1_error *error, const char *fmt, ...) __attribute__((format(printf, 3, 4)));
+
+#endif