1 files changed, 51 insertions, 19 deletions

diff --git a/libbuild2/scheduler.cxx b/libbuild2/scheduler.cxx
index bdd703d..e3fbcc1 100644
--- a/libbuild2/scheduler.cxx
+++ b/libbuild2/scheduler.cxx
@@ -5,8 +5,11 @@
 
 #if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__)
 #  include <pthread.h>
-#  ifdef __FreeBSD__
+#  if defined(__FreeBSD__)
 #    include <pthread_np.h> // pthread_attr_get_np() (in <pthread.h> on NetBSD)
+#  elif defined(__OpenBSD__)
+#    include <sys/signal.h>
+#    include <pthread_np.h> // pthread_stackseg_np()
 #  endif
 #endif
 
@@ -90,12 +93,11 @@ namespace build2
   }
 
   void scheduler::
-  deactivate (bool external)
+  deactivate_impl (bool external, lock&& rl)
   {
-    if (max_active_ == 1) // Serial execution.
-      return;
+    // Note: assume non-serial execution.
 
-    lock l (mutex_);
+    lock l (move (rl)); // Make sure unlocked on exception.
 
     active_--;
     waiting_++;
@@ -128,11 +130,10 @@ namespace build2
     }
   }
 
-  void scheduler::
-  activate (bool external, bool collision)
+  scheduler::lock scheduler::
+  activate_impl (bool external, bool collision)
   {
-    if (max_active_ == 1) // Serial execution.
-      return;
+    // Note: assume non-serial execution.
 
     lock l (mutex_);
 
@@ -157,6 +158,8 @@ namespace build2
 
     if (shutdown_)
       throw_generic_error (ECANCELED);
+
+    return l;
   }
 
   void scheduler::
@@ -204,7 +207,10 @@ namespace build2
   deallocate (size_t n)
   {
     if (max_active_ == 1) // Serial execution.
+    {
+      assert (n == 0);
       return;
+    }
 
     lock l (mutex_);
     active_ -= n;
@@ -213,13 +219,15 @@ namespace build2
   size_t scheduler::
   suspend (size_t start_count, const atomic_count& task_count)
   {
+    assert (max_active_ != 1); // Suspend during serial execution?
+
     wait_slot& s (
       wait_queue_[
         hash<const atomic_count*> () (&task_count) % wait_queue_size_]);
 
     // This thread is no longer active.
     //
-    deactivate (false /* external */);
+    deactivate_impl (false /* external */, lock (mutex_));
 
     // Note that the task count is checked while holding the lock. We also
     // have to notify while holding the lock (see resume()). The aim here
@@ -256,7 +264,7 @@ namespace build2
 
     // This thread is no longer waiting.
     //
-    activate (false /* external */, collision);
+    activate_impl (false /* external */, collision);
 
     return tc;
   }
@@ -362,8 +370,14 @@ namespace build2
            size_t init_active,
            size_t max_threads,
            size_t queue_depth,
-           optional<size_t> max_stack)
+           optional<size_t> max_stack,
+           size_t orig_max_active)
   {
+    if (orig_max_active == 0)
+      orig_max_active = max_active;
+    else
+      assert (max_active <= orig_max_active);
+
     // Lock the mutex to make sure our changes are visible in (other) active
     // threads.
     //
@@ -375,16 +389,18 @@ namespace build2
     // were asked to run serially.
     //
     if (max_threads == 0)
-      max_threads = (max_active == 1    ? 1 :
-                     sizeof (void*) < 8 ? 8 : 32) * max_active;
+      max_threads = (orig_max_active == 1
+                     ? 1
+                     : (sizeof (void*) < 8 ? 8 : 32) * orig_max_active);
 
     assert (shutdown_ &&
             init_active != 0 &&
             init_active <= max_active &&
-            max_active <= max_threads);
+            orig_max_active <= max_threads);
 
     active_ = init_active_ = init_active;
-    max_active_ = orig_max_active_ = max_active;
+    max_active_ = max_active;
+    orig_max_active_ = orig_max_active;
     max_threads_ = max_threads;
 
     // This value should be proportional to the amount of hardware concurrency
@@ -398,7 +414,7 @@ namespace build2
     //
     task_queue_depth_ = queue_depth != 0
       ? queue_depth
-      : max_active * 8;
+      : orig_max_active_ * 8;
 
     queued_task_count_.store (0, memory_order_relaxed);
 
@@ -421,6 +437,8 @@ namespace build2
 
     shutdown_ = false;
 
+    // Delay thread startup if serial.
+    //
     if (max_active_ != 1)
       dead_thread_ = thread (deadlock_monitor, this);
   }
@@ -429,7 +447,7 @@ namespace build2
   tune (size_t max_active)
   {
     // Note that if we tune a parallel scheduler to run serially, we will
-    // still have the deadlock monitoring thread running.
+    // still have the deadlock monitoring thread loitering around.
 
     // With multiple initial active threads we will need to make changes to
     // max_active_ visible to other threads and which we currently say can be
@@ -451,6 +469,11 @@ namespace build2
       lock l (wait_idle ());
 
       swap (max_active_, max_active);
+
+      // Start the deadlock thread if its startup was delayed.
+      //
+      if (max_active_ != 1 && !dead_thread_.joinable ())
+        dead_thread_ = thread (deadlock_monitor, this);
     }
 
     return max_active == orig_max_active_ ? 0 : max_active;
@@ -519,7 +542,7 @@ namespace build2
 
       // Wait for the deadlock monitor (the only remaining thread).
       //
-      if (orig_max_active_ != 1) // See tune() for why not max_active_.
+      if (dead_thread_.joinable ())
       {
         l.unlock ();
         dead_condv_.notify_one ();
@@ -835,6 +858,15 @@ namespace build2
       if (r != 0)
         throw_system_error (r);
 
+#elif defined(__OpenBSD__)
+      stack_t s;
+      int r (pthread_stackseg_np (pthread_self (), &s));
+
+      if (r != 0)
+        throw_system_error (r);
+
+      stack_size = s.ss_size;
+
 #else // defined(__APPLE__)
       stack_size = pthread_get_stacksize_np (pthread_self ());
 #endif