How do I verify if runtime failure is due to too many threads spawned?

Question

I am using `std::thread` and gcc as my compiler in implementing the parallel-merge as described in Cormen's Introduction to Algorithms. I think I got the code to work. It passes all randomly seeded arrays that are not too big. However, when I try to merge two arrays that are large (1e6 elements each), I get the following termination: ``` terminate called without an active exception terminate called recursively terminate called recursively ``` Using gdb doesn't help: it becomes corrupted during the run. I am pretty certain that the run has failed due to too many threads spawned. What can I do to confirm that this error is due to too many std::threads spawned? NOTES - Code works up to n=1e4, fails by n=1e5 define DEBUG if you want to see output, but I don't recommend this except for small n like 10 or 50. - STRBUF_SIZE/use of fprintf is ugly, but iostream doesn't flush well in threads - this is hacky, but works (no need to focus here). - I tried following Barnes53's suggestion by using…

Accepted Answer

You can catch `std::system_error` and check if the code is `resource_unavailable_try_again`: ``` #include #include #include #include #include class thread_collection { public: thread_collection() : mStop(false) {} ~thread_collection() { clear(); } template bool add(Func&& func, Args&&... args) { try { mThreads.emplace_back(std::forward(func), std::cref(mStop), std::forward(args)...); } catch (const std::system_error& e) { if (e.code().value() == std::errc::resource_unavailable_try_again) return false; // not possible to make more threads right now else throw; // something else } return true; // can keep going } void clear() { mStop = true; for (auto& thread : mThreads) { if (thread.joinable()) thread.join(); } mThreads.clear(); mStop = true; } std::size_t size() const { return mThreads.size(); } private: thread_collection(const thread_collection&); thread_collection& operator=(const thread_collection&); std::atomic mStop; std::vector mThreads; }; void worker(const std::atomic& stop) { while (!stop) std::this_thread::yield(); } int main() { thread_collection threads; try { while (threads.add(worker)) continue; std::cout << "Exhausted thread resources!" << std::endl; } catch (const std::exception& e) { std::cout << "Stopped for some other reason: " << e.what() << std::endl; } std::cout << "Made: " << threads.size() << " threads." << std::endl; threads.clear(); } ``` (Run this at your own risk!) According §30.3.1.2/4, this is the error code used to indicate thread creation failure: Error conditions: resource_unavailable_try_again — the system lacked the necessary resources to create another thread, or the system-imposed limit on the number of threads in a process would be exceeded. Note this could be thrown by your own arguments being copied to the resulting thread. To guarantee against this, you need to pre-construct your arguments, then no-throw move them to your thread function. That said, you're much better off putting a limit on thread creation anyway. There's no point in having more threads running than cores can execute. Use `std::thread::hardware_concurrency` to get that number.

How do I verify if runtime failure is due to too many threads spawned?

Solution

Problem

Related problems