Remove submodule CTPL, replace its functionality by calls to std::async (KhronosGroup#1378)

Author: asuessenbach

.gitmodules

@@ -34,9 +34,6 @@
 [submodule "third_party/astc"]
 	path = third_party/astc
 	url = https://github.com/ARM-software/astc-encoder
-[submodule "third_party/CTPL"]
-	path = third_party/CTPL
-	url = https://github.com/vit-vit/CTPL
 [submodule "third_party/vulkan"]
 	path = third_party/vulkan
 	url = https://github.com/KhronosGroup/Vulkan-Headers

framework/CMakeLists.txt

@@ -503,7 +503,6 @@ target_link_libraries(${PROJECT_NAME} PUBLIC
     vma
     spirv-cross-glsl
     spdlog
-    ctpl
     plugins)
 
 if(${NEED_LINK_ATOMIC})

framework/gltf_loader.cpp

@@ -19,6 +19,7 @@
 #define TINYGLTF_IMPLEMENTATION
 #include "gltf_loader.h"
 
+#include <future>
 #include <limits>
 #include <queue>
 
@@ -51,8 +52,6 @@
 #include "scene_graph/scene.h"
 #include "scene_graph/scripts/animation.h"
 
-#include <ctpl_stl.h>
-
 namespace vkb
 {
 namespace
@@ -551,25 +550,19 @@ sg::Scene GLTFLoader::load_scene(int scene_index, VkBufferUsageFlags additional_
 	timer.start();
 
 	// Load images
-	auto thread_count = std::thread::hardware_concurrency();
-	thread_count      = thread_count == 0 ? 1 : thread_count;
-	ctpl::thread_pool thread_pool(thread_count);
-
 	auto image_count = to_u32(model.images.size());
 
 	std::vector<std::future<std::unique_ptr<sg::Image>>> image_component_futures;
 	for (size_t image_index = 0; image_index < image_count; image_index++)
 	{
-		auto fut = thread_pool.push(
-		    [this, image_index](size_t) {
+		image_component_futures.push_back(std::async(
+		    [this, image_index]() {
 			    auto image = parse_image(model.images[image_index]);
 
 			    LOGI("Loaded gltf image #{} ({})", image_index, model.images[image_index].uri.c_str());
 
 			    return image;
-		    });
-
-		image_component_futures.push_back(std::move(fut));
+		    }));
 	}
 
 	std::vector<std::unique_ptr<sg::Image>> image_components;
@@ -626,6 +619,8 @@ sg::Scene GLTFLoader::load_scene(int scene_index, VkBufferUsageFlags additional_
 
 	auto elapsed_time = timer.stop();
 
+	auto thread_count = std::thread::hardware_concurrency();
+	thread_count      = thread_count == 0 ? 1 : thread_count;
 	LOGI("Time spent loading images: {} seconds across {} threads.", vkb::to_string(elapsed_time), thread_count);
 
 	// Load textures

samples/performance/command_buffer_usage/command_buffer_usage.cpp

@@ -369,10 +369,13 @@ void CommandBufferUsage::ForwardSubpassSecondary::draw(vkb::core::CommandBufferC
 
 			if (state.multi_threading)
 			{
-				auto fut = thread_pool.push(
-				    [this, cb_count, &primary_command_buffer, &sorted_opaque_nodes, mesh_start, mesh_end](size_t thread_id) {
-					    return record_draw_secondary(primary_command_buffer, sorted_opaque_nodes, mesh_start, mesh_end, thread_id);
-				    });
+				auto fut = thread_pool.push(std::bind(&CommandBufferUsage::ForwardSubpassSecondary::record_draw_secondary,
+				                                      this,
+				                                      std::ref(primary_command_buffer),
+				                                      std::cref(sorted_opaque_nodes),
+				                                      mesh_start,
+				                                      mesh_end,
+				                                      std::placeholders::_1));
 
 				secondary_cmd_buf_futures.push_back(std::move(fut));
 			}

samples/performance/command_buffer_usage/command_buffer_usage.h

@@ -17,8 +17,6 @@
 
 #pragma once
 
-#include <ctpl_stl.h>
-
 #include "buffer_pool.h"
 #include "common/utils.h"
 #include "rendering/render_pipeline.h"
@@ -28,6 +26,86 @@
 #include "scene_graph/components/perspective_camera.h"
 #include "vulkan_sample.h"
 
+class ThreadPool
+{
+  public:
+	explicit ThreadPool() :
+	    stop_flag(false)
+	{}
+
+	~ThreadPool()
+	{
+		shutdown();
+	}
+
+	template <class F, class... Args>
+	auto push(F &&f, Args &&...args) -> std::future<std::invoke_result_t<F, Args..., size_t>>
+	{
+		using return_type                 = std::invoke_result_t<F, Args..., size_t>;
+		auto                     task_ptr = std::make_shared<std::packaged_task<return_type(size_t)>>(std::bind(std::forward<F>(f), std::forward<Args>(args)..., std::placeholders::_1));
+		std::future<return_type> res      = task_ptr->get_future();
+		{
+			std::unique_lock<std::mutex> lock(queue_mutex);
+			tasks.emplace([task_ptr](size_t thread_index) { (*task_ptr)(thread_index); });
+		}
+		condition.notify_one();
+		return res;
+	}
+
+	void resize(size_t thread_count)
+	{
+		if (thread_count != workers.size())
+		{
+			shutdown();
+
+			for (size_t i = 0; i < thread_count; ++i)
+			{
+				workers.emplace_back([this, i] {
+					size_t thread_index = i;
+					while (true)
+					{
+						std::function<void(size_t)> task;
+						{
+							std::unique_lock<std::mutex> lock(queue_mutex);
+							condition.wait(lock, [this] { return stop_flag || !tasks.empty(); });
+							if (stop_flag && tasks.empty())
+								return;
+							task = std::move(tasks.front());
+							tasks.pop();
+						}
+						task(thread_index);
+					}
+				});
+			}
+		}
+	}
+
+	void shutdown()
+	{
+		{
+			std::unique_lock<std::mutex> lock(queue_mutex);
+			stop_flag = true;
+		}
+		condition.notify_all();
+		for (auto &worker : workers)
+			worker.join();
+		workers.clear();
+		stop_flag = false;
+	}
+
+	size_t size() const
+	{
+		return workers.size();
+	}
+
+  private:
+	std::vector<std::thread>                workers;
+	std::queue<std::function<void(size_t)>> tasks;
+	std::mutex                              queue_mutex;
+	std::condition_variable                 condition;
+	std::atomic<bool>                       stop_flag;
+};
+
 /**
  * @brief Sample showing the use of secondary command buffers for
  *        multi-threaded recording, as well as the different
@@ -124,7 +202,7 @@ class CommandBufferUsage : public vkb::VulkanSampleC
 
 		float avg_draws_per_buffer{0};
 
-		ctpl::thread_pool thread_pool;
+		ThreadPool thread_pool;
 	};
 
   private:

samples/performance/multithreading_render_passes/multithreading_render_passes.cpp

@@ -198,11 +198,6 @@ std::vector<std::shared_ptr<vkb::core::CommandBufferC>>
 	auto use_multithreading = multithreading_mode != static_cast<int>(MultithreadingMode::None);
 	shadow_subpass->set_thread_index(use_multithreading ? 1 : 0);
 
-	if (use_multithreading && thread_pool.size() < 1)
-	{
-		thread_pool.resize(1);
-	}
-
 	switch (multithreading_mode)
 	{
 		case static_cast<int>(MultithreadingMode::PrimaryCommandBuffers):
@@ -234,8 +229,8 @@ void MultithreadingRenderPasses::record_separate_primary_command_buffers(std::ve
 	    get_render_context().get_active_frame().get_command_pool(queue, reset_mode, 1).request_command_buffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY);
 
 	// Recording shadow command buffer
-	auto shadow_buffer_future = thread_pool.push(
-	    [this, shadow_command_buffer](size_t thread_id) {
+	auto shadow_buffer_future = std::async(
+	    [this, shadow_command_buffer]() {
 		    shadow_command_buffer->begin(VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
 		    draw_shadow_pass(*shadow_command_buffer);
 		    shadow_command_buffer->end();
@@ -278,9 +273,10 @@ void MultithreadingRenderPasses::record_separate_secondary_command_buffers(std::
 	auto &scene_framebuffer   = get_device().get_resource_cache().request_framebuffer(scene_render_target, scene_render_pass);
 
 	// Recording shadow command buffer
-	auto shadow_buffer_future = thread_pool.push(
-	    [this, shadow_command_buffer, &shadow_render_pass, &shadow_framebuffer](size_t thread_id) {
-		    shadow_command_buffer->begin(VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, &shadow_render_pass, &shadow_framebuffer, 0);
+	auto shadow_buffer_future = std::async(
+	    [this, shadow_command_buffer, &shadow_render_pass, &shadow_framebuffer]() {
+		    shadow_command_buffer->begin(
+		        VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, &shadow_render_pass, &shadow_framebuffer, 0);
 		    draw_shadow_pass(*shadow_command_buffer);
 		    shadow_command_buffer->end();
 	    });

samples/performance/multithreading_render_passes/multithreading_render_passes.h

@@ -17,8 +17,6 @@
 
 #pragma once
 
-#include <ctpl_stl.h>
-
 #include "core/command_buffer.h"
 #include "rendering/render_pipeline.h"
 #include "rendering/subpasses/forward_subpass.h"
@@ -150,8 +148,6 @@ class MultithreadingRenderPasses : public vkb::VulkanSampleC
 	 */
 	vkb::sg::Camera *camera{};
 
-	ctpl::thread_pool thread_pool;
-
 	uint32_t swapchain_attachment_index{0};
 
 	uint32_t depth_attachment_index{1};

third_party/CMakeLists.txt

@@ -371,12 +371,6 @@ set(SPDLOG_FMT_EXTERNAL ON)
 add_subdirectory(spdlog)
 set_property(TARGET spdlog PROPERTY FOLDER "ThirdParty")
 
-# ctpl
-add_library(ctpl INTERFACE)
-set(CTPL_DIR ${CMAKE_CURRENT_SOURCE_DIR}/CTPL)
-target_sources(ctpl INTERFACE ${CTPL_DIR}/ctpl_stl.h)
-target_include_directories(ctpl SYSTEM INTERFACE ${CTPL_DIR})
-
 # OpenCL
 add_library(opencl INTERFACE)
 set(OPENCL_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/opencl)

third_party/CTPL

@@ -1,5 +1,5 @@
 ////
-- Copyright (c) 2019-2024, Arm Limited and Contributors
+- Copyright (c) 2019-2025, Arm Limited and Contributors
 -
 - SPDX-License-Identifier: Apache-2.0
 -
@@ -23,9 +23,7 @@
 This project has multiple third-party dependencies, each of which may have independent licensing:
 
 * https://github.com/ARM-software/astc-encoder[astc-encoder]: ASTC Evaluation Codec
-* https://github.com/catchorg/Catch2[Catch2]: Modern C++ test framework
 * https://github.com/CLIUtils/CLI11[CLI11] Command line parser for C++11 and beyond
-* https://github.com/vit-vit/CTPL[CTPL]: Thread Pool Library
 * https://github.com/fmtlib/fmt[fmt]: A modern formating library
 * https://github.com/glfw/glfw[glfw]: A multi-platform library for OpenGL, OpenGL ES, Vulkan, window and input
 * https://github.com/g-truc/glm[glm]: OpenGL Mathematics