Refactor set of soft_limit to fix a bug

src/tbb/thread_request_serializer.cpp

@@ -100,13 +100,12 @@ void thread_request_serializer_proxy::set_active_num_workers(int soft_limit) {
 
     if (soft_limit != 0) {
         my_is_mandatory_concurrency_enabled = false;
-        my_serializer.set_active_num_workers(soft_limit);
-    } else {
-        if (my_num_mandatory_requests > 0 && !my_is_mandatory_concurrency_enabled) {
-            my_is_mandatory_concurrency_enabled = true;
-            my_serializer.set_active_num_workers(1);
-        }
+    } else if (my_num_mandatory_requests > 0) {
+        my_is_mandatory_concurrency_enabled = true;
+        soft_limit = 1;
     }
+
+    my_serializer.set_active_num_workers(soft_limit);
 }
 
 int thread_request_serializer_proxy::num_workers_requested() { return my_serializer.num_workers_requested(); }

test/tbb/test_global_control.cpp

@@ -22,6 +22,7 @@
 #include "common/utils.h"
 #include "common/spin_barrier.h"
 #include "common/utils_concurrency_limit.h"
+#include "common/cpu_usertime.h"
 
 #include "tbb/global_control.h"
 #include "tbb/parallel_for.h"
@@ -272,3 +273,30 @@ TEST_CASE("test concurrent task_scheduler_handle destruction") {
     stop = true;
     thr1.join();
 }
+
+//! \brief \ref regression
+TEST_CASE("Thread should sleep when soft_limit is zero") {
+    int num_threads = int(utils::get_platform_max_threads());
+    std::atomic<int> barrier{num_threads};
+
+    // Warm-up threads
+    tbb::parallel_for(0, num_threads, [&] (int) {
+        --barrier;
+        while (barrier > 0) {
+            std::this_thread::yield();
+        }
+    });
+
+    tbb::global_control control(tbb::global_control::max_allowed_parallelism, 1);
+
+    std::thread thr([&] {
+        tbb::parallel_for(0, 100000, [&] (int) {
+            utils::doDummyWork(100);
+        });
+    });
+
+    // Workers should sleep because of the soft_limit
+    TestCPUUserTime(utils::get_platform_max_threads() - 1);
+
+    thr.join();
+}