1 files changed, 56 insertions, 12 deletions

diff --git a/libbuild2/scheduler.hxx b/libbuild2/scheduler.hxx
index dc18859..3cc206e 100644
--- a/libbuild2/scheduler.hxx
+++ b/libbuild2/scheduler.hxx
@@ -7,7 +7,8 @@
 #include <list>
 #include <tuple>
 #include <atomic>
-#include <type_traits>        // aligned_storage, etc
+#include <cstddef>     // max_align_t
+#include <type_traits> // decay, etc
 
 #include <libbuild2/types.hxx>
 #include <libbuild2/utility.hxx>
@@ -191,13 +192,15 @@ namespace build2
     //
     // The external flag indicates whether the wait is for an event external
     // to the scheduler, that is, triggered by something other than one of the
-    // threads managed by the scheduler.
+    // threads managed by the scheduler. This is used to suspend deadlock
+    // detection (which is progress-based and which cannot be measured for
+    // external events).
     //
     void
     deactivate (bool external);
 
     void
-    activate (bool external, bool = false);
+    activate (bool external);
 
     // Sleep for the specified duration, deactivating the thread before going
     // to sleep and re-activating it after waking up (which means this
@@ -216,7 +219,7 @@ namespace build2
     // Allocate additional active thread count to the current active thread,
     // for example, to be "passed" to an external program:
     //
-    // scheduler::alloc_guard ag (ctx.sched, ctx.sched.max_active () / 2);
+    // scheduler::alloc_guard ag (*ctx.sched, ctx.sched->max_active () / 2);
     // args.push_back ("-flto=" + to_string (1 + ag.n));
     // run (args);
     // ag.deallocate ();
@@ -241,14 +244,38 @@ namespace build2
     void
     deallocate (size_t);
 
+    // Similar to allocate() but reserve all the available threads blocking
+    // until this becomes possible. Call unlock() on the specified lock before
+    // deactivating and lock() after activating (can be used to unlock the
+    // phase). Typical usage:
+    //
+    // scheduler::alloc_guard ag (*ctx.sched,
+    //                            phase_unlock (ctx, true /* delay */));
+    //
+    // Or, without unlocking the phase:
+    //
+    // scheduler::alloc_guard ag (*ctx.sched, phase_unlock (nullptr));
+    //
+    template <typename L>
+    size_t
+    serialize (L& lock);
+
     struct alloc_guard
     {
       size_t n;
 
       alloc_guard (): n (0), s_ (nullptr) {}
       alloc_guard (scheduler& s, size_t m): n (s.allocate (m)), s_ (&s) {}
-      alloc_guard (alloc_guard&& x): n (x.n), s_ (x.s_) {x.s_ = nullptr;}
-      alloc_guard& operator= (alloc_guard&& x)
+
+      template <typename L,
+                typename std::enable_if<!std::is_integral<L>::value, int>::type = 0>
+      alloc_guard (scheduler& s, L&& l): n (s.serialize (l)), s_ (&s) {}
+
+      alloc_guard (alloc_guard&& x) noexcept
+        : n (x.n), s_ (x.s_) {x.s_ = nullptr;}
+
+      alloc_guard&
+      operator= (alloc_guard&& x) noexcept
       {
         if (&x != this)
         {
@@ -353,12 +380,19 @@ namespace build2
     size_t
     tune (size_t max_active);
 
+    bool
+    tuned () const {return max_active_ != orig_max_active_;}
+
     struct tune_guard
     {
       tune_guard (): s_ (nullptr), o_ (0) {}
       tune_guard (scheduler& s, size_t ma): s_ (&s), o_ (s_->tune (ma)) {}
-      tune_guard (tune_guard&& x): s_ (x.s_), o_ (x.o_) {x.s_ = nullptr;}
-      tune_guard& operator= (tune_guard&& x)
+
+      tune_guard (tune_guard&& x) noexcept
+        : s_ (x.s_), o_ (x.o_) {x.s_ = nullptr;}
+
+      tune_guard&
+      operator= (tune_guard&& x) noexcept
       {
         if (&x != this)
         {
@@ -426,8 +460,8 @@ namespace build2
     {
       explicit
       monitor_guard (scheduler* s = nullptr): s_ (s) {}
-      monitor_guard (monitor_guard&& x): s_ (x.s_) {x.s_ = nullptr;}
-      monitor_guard& operator= (monitor_guard&& x)
+      monitor_guard (monitor_guard&& x) noexcept: s_ (x.s_) {x.s_ = nullptr;}
+      monitor_guard& operator= (monitor_guard&& x) noexcept
       {
         if (&x != this)
         {
@@ -543,8 +577,8 @@ namespace build2
 
       atomic_count* task_count;
       size_t start_count;
-      func_type func;
       args_type args;
+      func_type func;
 
       template <size_t... i>
       void
@@ -673,7 +707,11 @@ namespace build2
     //
     struct task_data
     {
-      std::aligned_storage<sizeof (void*) * 8>::type data;
+      static const size_t data_size = (sizeof (void*) == 4
+                                       ? sizeof (void*) * 16
+                                       : sizeof (void*) * 8);
+
+      alignas (std::max_align_t) unsigned char data[data_size];
       void (*thunk) (scheduler&, lock&, void*);
     };
 
@@ -923,6 +961,12 @@ namespace build2
   private:
     optional<size_t>
     wait_impl (size_t, const atomic_count&, work_queue);
+
+    void
+    deactivate_impl (bool, lock&&);
+
+    lock
+    activate_impl (bool, bool);
   };
 }