Added multithreading support to bogosort

Author: Dynamitos

SortVisualizer/SortVisualizer.vcxproj

@@ -22,34 +22,38 @@
     <VCProjectVersion>15.0</VCProjectVersion>
     <ProjectGuid>{F31A1120-4D21-41B1-A0AD-FBD0EF6BAF0B}</ProjectGuid>
     <RootNamespace>SortVisualizer</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
+    <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
+    <SpectreMitigation>false</SpectreMitigation>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
+    <PlatformToolset>v142</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
+    <SpectreMitigation>false</SpectreMitigation>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
+    <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
+    <SpectreMitigation>false</SpectreMitigation>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
+    <PlatformToolset>v142</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
+    <SpectreMitigation>false</SpectreMitigation>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings" />

SortVisualizer/bogosort.cpp

@@ -1,39 +1,74 @@
 #include "bogosort.h"
+#include <atomic>
 
 BogoSort::BogoSort()
 {
-    this->name = "Bogo sort";
+	this->name = "Bogo sort";
 }
-
+std::mutex mutex;
+std::atomic_bool sorted = false;
+int32_t sortedThreadIndex = -1;
 void BogoSort::sort(float* data, int size, int delay)
 {
-	bool sorted = false;
-	while (!sorted)
+	uint32_t numThreads = useMultithreading ? std::thread::hardware_concurrency() : 1;
+	float** threadData = new float* [numThreads];
+	threadData[0] = data;
+	for (int i = 1; i < numThreads; ++i)
 	{
-        randomShuffle(data, size);
+		threadData[i] = new float[size];
+		std::memcpy(threadData[i], data, sizeof(float) * size);
+	}
+	std::vector<std::thread> threads(numThreads);
 
-		sorted = true;
-#pragma loop(hint_parallel(8))
-		for (int i = 0; i < size - 1; ++i)
+	auto runLambda = [threadData, size](int threadIndex, bool useAssembly) {
+		bool localSorted = false;
+		while (!localSorted && !sorted)
 		{
-			if (data[i] > data[i + 1])
+			int randomIndex = 0;
+			for (int i = 0; i < size; i++)
+			{
+				randomIndex = rand() % size;
+				if (useAssembly)
+				{
+					asmswap(&threadData[threadIndex][i], &threadData[threadIndex][randomIndex]);
+				}
+				else
+				{
+					float floatHelper = threadData[threadIndex][i];
+					threadData[threadIndex][i] = threadData[threadIndex][randomIndex];
+					threadData[threadIndex][randomIndex] = floatHelper;
+				}
+			}
+			localSorted = true;
+			for (int i = 0; i < size - 1; ++i)
 			{
-				sorted = false;
-				break;
+				if (threadData[threadIndex][i] > threadData[threadIndex][i + 1])
+				{
+					localSorted = false;
+					break;
+				}
 			}
 		}
+		if (!localSorted)
+			return;
+		{
+			std::unique_lock<std::mutex> lock(mutex);
+			sorted.store(true);
+			sortedThreadIndex = threadIndex;
+		}
+	};
+	for (int i = 0; i < numThreads; ++i)
+	{
+		threads[i] = std::thread(runLambda, i, useAssembly);
 	}
-}
-
-
-void BogoSort::randomShuffle(float* data, int size)
-{
-    int randomIndex = 0;
-    for (int i = 0; i < size; i++)
-    {
-        randomIndex = rand() % size;
-        floatHelper = data[i];
-        data[i] = data[randomIndex];
-        data[randomIndex] = floatHelper;
-    }
-}
+	for (int i = 0; i < numThreads; ++i)
+	{
+		threads[i].join();
+	}
+	threads.clear();
+	std::memcpy(data, threadData[sortedThreadIndex], sizeof(float) * size);
+	for (int i = 1; i < numThreads; ++i)
+	{
+		delete threadData[i];
+	}
+}

SortVisualizer/bogosort.h

@@ -1,10 +1,9 @@
 #pragma once
-#include "selectionsort.h"
+#include "sortalgorithm.h"
 
 class BogoSort : public SortAlgorithm
 {
 public:
     BogoSort();
 	virtual void sort(float data[], int size, int intDelay);
-    void randomShuffle(float* data, int size);
 };

SortVisualizer/commandparser.cpp

@@ -31,14 +31,14 @@ CommandParser::CommandParser()
 		("selectionsort", "Selection Sort, standard implementation")
 		("stdsort", "qsort() algorithm used by the c++ standard library");
 	options.add_options("Visualizations")
-		("g,gradient", "Gradient Visualization. An ellipse as base, every array entry is a vertex and the value of a vertex is represented by it's HSV hue value, with the sorted array being the 2D HSV colorspace")
-		("c,column", "Column Visualization. Every array entry is represented by a column, with the height of the column representing it's value. The sorted array has the lower left part of the screen white and the rest black")
-		("l,line", "Line Visualization. Every value is represented by a line, with the color of the line being its HSV hue value. The path of the line represents it's path through the array");
+		("g,gradient", "Gradient Visualization. An ellipse as base, every array entry is a vertex and the value of a vertex is represented by it's HSV hue value, with the sorted array being the 2D HSV colorspace", cxxopts::value<bool>(g))
+		("c,column", "Column Visualization. Every array entry is represented by a column, with the height of the column representing it's value. The sorted array has the lower left part of the screen white and the rest black", cxxopts::value<bool>(c))
+		("l,line", "Line Visualization. Every value is represented by a line, with the color of the line being its HSV hue value. The path of the line represents it's path through the array", cxxopts::value<bool>(l));
 	options.add_options("Misc")
 		("d,delay", "Specifies the delay after each array operation in milliseconds, does not work with assembly code", cxxopts::value<int>(delay))
-		("a,assembly", "Use this to toggle assembly usage whenever possible")
-		//("m,multithread", "Use this to toggle usage of multithreading whenever possible")
-		("v,vulkan", "Use this to toggle usage of Vulkan for rendering whenever possible")
+		("a,assembly", "Use this to toggle assembly usage whenever possible", cxxopts::value<bool>(a))
+		("m,multithread", "Use this to toggle usage of multithreading whenever possible", cxxopts::value<bool>(mt))
+		("v,vulkan", "Use this to toggle usage of Vulkan for rendering whenever possible", cxxopts::value<bool>(vulkan))
 		("n,elements", "Specifies the number of elements to sort", cxxopts::value<int>(number))
 		("h,help", "Show this page");
 }
@@ -97,34 +97,35 @@ void CommandParser::parseCommandLine(int argc, char * argv[])
 	{
 		algorithm = new StdSort();
 	}
+	algorithm->intDelay = delay;
 	algorithm->useAssembly = a;
 	algorithm->useMultithreading = mt;
-	if (result.count("v"))
+	if (vulkan)
 	{
-		if (result.count("g"))
+		if (g)
 		{
 			visualization = new VulkanGradientVisualization(number);
 		}
-		else if (result.count("c"))
+		else if (c)
 		{
 			visualization = new VulkanColumnVisualization(number);
 		}
-		else if (result.count("l"))
+		else if (l)
 		{
 			visualization = new LineVisualization(number);
 		}
 	}
 	else
 	{
-		if (result.count("g"))
+		if (g)
 		{
 			visualization = new GradientVisualization(number);
 		}
-		else if (result.count("c"))
+		else if (c)
 		{
 			visualization = new ColumnVisualization(number);
 		}
-		else if (result.count("l"))
+		else if (l)
 		{
 			visualization = new LineVisualization(number);
 		}

SortVisualizer/commandparser.h

@@ -12,7 +12,12 @@ class CommandParser
 	SortAlgorithm* getAlgorithm() { return algorithm; }
 	int getDelay() { return delay; }
 private:
-	bool a, mt;
+	bool vulkan{ false };
+	bool a{ false };
+	bool mt{ false };
+	bool g{ false };
+	bool c{ false };
+	bool l{ false };
 	int delay;
 	int number;
 	cxxopts::Options options;

SortVisualizer/display.cpp

@@ -27,7 +27,10 @@ void Display::createWindow(bool noContext)
 
     glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods) {if (action == GLFW_PRESS && key == GLFW_KEY_ESCAPE) glfwSetWindowShouldClose(window, GLFW_TRUE); });
 
-	glfwMakeContextCurrent(window);
+	if (!noContext)
+	{
+		glfwMakeContextCurrent(window);
+	}
 
 	lastTime = glfwGetTime();
 }

SortVisualizer/main.cpp

@@ -24,11 +24,35 @@
 
 int main(int argc, char* argv[])
 {
+	/*glfwInit();
+	glfwSetErrorCallback([](int index, const char* error) {std::cout << error << std::endl; });
+
+	VkApplicationInfo appInfo = {};
+	appInfo.apiVersion = VK_API_VERSION_1_1;
+	appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
+	appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
+	appInfo.pApplicationName = "Vulkan Test";
+	appInfo.pEngineName = "Vulkan Engine";
+	VkInstanceCreateInfo instanceInfo = {};
+	instanceInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+	instanceInfo.pNext = nullptr;
+	instanceInfo.flags = 0;
+	std::vector<const char*> standardvalidation = { "VK_LAYER_LUNARG_standard_validation", "VK_LAYER_LUNARG_api_dump" };
+	instanceInfo.enabledLayerCount = standardvalidation.size();
+	instanceInfo.ppEnabledLayerNames = standardvalidation.data();
+	uint32_t glfwExtensionCount;
+	const char** glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
+	instanceInfo.enabledExtensionCount = glfwExtensionCount;
+	instanceInfo.ppEnabledExtensionNames = glfwExtensions;
+	instanceInfo.pApplicationInfo = &appInfo;
+
+	VkInstance instance;
+	VK_CHECK(vkCreateInstance(&instanceInfo, nullptr, &instance));*/
 	CommandParser* parser = new CommandParser();
 	parser->parseCommandLine(argc, argv);
 	SortAlgorithm* algo = parser->getAlgorithm();
 	Visualization* renderer = parser->getVisualization();
-	renderer->init(1000);
+	renderer->init(parser->getDelay());
 	renderer->setAlgorithm(algo);
 	renderer->loop();
 	delete renderer;

SortVisualizer/utils.cpp

@@ -781,6 +781,7 @@ QueueFamilyIndices util::findQueueFamilies(VkPhysicalDevice physicalDevice)
 
 	if (indices.dedicatedTransfer != -1)
 	{
+		//std::cout << "Disabled dedicated transfer, uncomment to enable" << std::endl;
 		std::cout << "using dedicated transfer" << std::endl;
 		indices.transferFamily = indices.dedicatedTransfer;
 	}

SortVisualizer/utils.h

@@ -110,7 +110,8 @@ struct SwapChainSupportDetails {
 	std::vector<VkPresentModeKHR> presentModes;
 };
 static const std::vector<const char*> validationLayers = {
-	"VK_LAYER_LUNARG_standard_validation"
+	"VK_LAYER_LUNARG_standard_validation",
+	"VK_LAYER_LUNARG_api_dump"
 };
 static const std::vector<const char*> deviceExtensions = {
 	"VK_KHR_swapchain"