Reduce use of FastOS_Mutex and FastOS_Cond.

Remove handover tricks, use move constructor and move assignment instead.

8 files changed, 158 insertions, 286 deletions

diff --git a/documentapi/src/tests/systemstate/systemstate.cpp b/documentapi/src/tests/systemstate/systemstate.cpp
index 7aadf82aeed..3e42c94950a 100644
--- a/documentapi/src/tests/systemstate/systemstate.cpp
+++ b/documentapi/src/tests/systemstate/systemstate.cpp
@@ -174,7 +174,7 @@ Test::testHandle()
     SystemStateHandle handle(*state);
     ASSERT_TRUE(handle.isValid());
 
-    SystemStateHandle hoe(handle);
+    SystemStateHandle hoe(std::move(handle));
     ASSERT_TRUE(!handle.isValid());
     ASSERT_TRUE(hoe.isValid());
 }
diff --git a/documentapi/src/vespa/documentapi/messagebus/systemstate/systemstatehandle.cpp b/documentapi/src/vespa/documentapi/messagebus/systemstate/systemstatehandle.cpp
index ad2f4485ac8..9ccaece4511 100644
--- a/documentapi/src/vespa/documentapi/messagebus/systemstate/systemstatehandle.cpp
+++ b/documentapi/src/vespa/documentapi/messagebus/systemstate/systemstatehandle.cpp
@@ -4,34 +4,28 @@
 
 using namespace documentapi;
 
-SystemStateHandover::SystemStateHandover(SystemState *state, vespalib::LockGuard &guard) :
-    _state(state),
-    _guard(guard)
-{}
-
 SystemStateHandle::SystemStateHandle(SystemState &state) :
     _state(&state),
     _guard(*state._lock)
 {}
 
-SystemStateHandle::SystemStateHandle(SystemStateHandle &rhs) :
+SystemStateHandle::SystemStateHandle(SystemStateHandle &&rhs) :
     _state(rhs._state),
-    _guard(rhs._guard)
+    _guard(std::move(rhs._guard))
 {
     rhs._state = nullptr;
 }
 
-SystemStateHandle::SystemStateHandle(const SystemStateHandover &rhs) :
-    _state(rhs._state),
-    _guard(rhs._guard)
-{}
+SystemStateHandle &
+SystemStateHandle::operator=(SystemStateHandle &&rhs)
+{
+    if (this != &rhs) {
+        _state = rhs._state;
+        _guard = std::move(rhs._guard);
+        rhs._state = nullptr;
+    }
+    return *this;
+}
 
 SystemStateHandle::~SystemStateHandle() {}
 
-SystemStateHandle::operator
-SystemStateHandover() {
-    SystemStateHandover ret(_state, _guard);
-    _state = nullptr;
-    return ret;
-}
-
diff --git a/documentapi/src/vespa/documentapi/messagebus/systemstate/systemstatehandle.h b/documentapi/src/vespa/documentapi/messagebus/systemstate/systemstatehandle.h
index aa87e1ee0ab..f0342cfb2de 100644
--- a/documentapi/src/vespa/documentapi/messagebus/systemstate/systemstatehandle.h
+++ b/documentapi/src/vespa/documentapi/messagebus/systemstate/systemstatehandle.h
@@ -7,31 +7,15 @@
 namespace documentapi {
 
 /**
- * Implements a handover class to enable the system state handler to be perform handover even on const objects
- * such as occur when returning a handle by value from a function.
- */
-class SystemStateHandover {
-    friend class SystemStateHandle;
-private:
-    SystemStateHandover(const SystemStateHandover &);
-    SystemStateHandover &operator=(const SystemStateHandover &);
-    SystemStateHandover(SystemState *state, vespalib::LockGuard &guard);
-
-private:
-    SystemState                *_state;
-    mutable vespalib::LockGuard _guard;
-};
-
-/**
- * Implements a handle to grant synchronized access to the content of a system state object. This needs the
- * above handover class to be able to return itself from methods that create it.
+ * Implements a handle to grant synchronized access to the content of a system state object.
  */
 class SystemStateHandle {
 private:
     SystemState        *_state; // The associated system state for which this object is a handler.
     vespalib::LockGuard _guard; // The lock guard for the system state's lock.
 
-    SystemState &operator=(const SystemStateHandle &rhs); // hide
+    SystemStateHandle &operator=(const SystemStateHandle &) = delete;
+    SystemStateHandle(const SystemStateHandle &) = delete;
 
 public:
     /**
@@ -42,28 +26,19 @@ public:
     SystemStateHandle(SystemState &state);
 
     /**
-     * Implements the copy constructor.
-     *
-     * @param rhs The handle to copy to this.
-     */
-    SystemStateHandle(SystemStateHandle &rhs);
-
-    /**
-     * Implements the copy constructor for a const handle.
+     * Implements the move constructor.
      *
-     * @param rhs The handle to copy to this.
+     * @param rhs The handle to move to this.
      */
-    SystemStateHandle(const SystemStateHandover &rhs);
+    SystemStateHandle(SystemStateHandle &&rhs);
 
+    SystemStateHandle &operator=(SystemStateHandle &&rhs);
     /**
      * Destructor. Releases the contained lock on the associated system state object. There is no unlock()
      * mechanism provided, since this will happen automatically as soon as this handle goes out of scope.
      */
     ~SystemStateHandle();
 
-    /** Implements a cast-operator for handover. */
-    operator SystemStateHandover();
-
     /** Returns whether or not this handle is valid. */
     bool isValid() const { return _state != NULL; }
 
diff --git a/searchlib/src/vespa/searchlib/docstore/compacter.cpp b/searchlib/src/vespa/searchlib/docstore/compacter.cpp
index fa6a34db4ac..4d154da9907 100644
--- a/searchlib/src/vespa/searchlib/docstore/compacter.cpp
+++ b/searchlib/src/vespa/searchlib/docstore/compacter.cpp
@@ -16,7 +16,7 @@ void
 Compacter::write(LockGuard guard, uint32_t chunkId, uint32_t lid, const void *buffer, size_t sz) {
     (void) chunkId;
     FileChunk::FileId fileId= _ds.getActiveFileId(guard);
-    _ds.write(guard, fileId, lid, buffer, sz);
+    _ds.write(std::move(guard), fileId, lid, buffer, sz);
 }
 
 BucketCompacter::BucketCompacter(size_t maxSignificantBucketBits, const CompressionConfig & compression, LogDataStore & ds, ThreadExecutor & executor, const IBucketizer & bucketizer, FileId source, FileId destination) :
@@ -92,7 +92,7 @@ BucketCompacter::write(BucketId bucketId, uint32_t chunkId, uint32_t lid, const
     LidInfo lidInfo(_sourceFileId.getId(), chunkId, sz);
     if (_ds.getLid(_lidGuard, lid) == lidInfo) {
         FileId fileId = getDestinationId(guard);
-        _ds.write(guard, fileId, lid, buffer, sz);
+        _ds.write(std::move(guard), fileId, lid, buffer, sz);
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/docstore/filechunk.cpp b/searchlib/src/vespa/searchlib/docstore/filechunk.cpp
index 93a85eda0aa..e9a1ffcda20 100644
--- a/searchlib/src/vespa/searchlib/docstore/filechunk.cpp
+++ b/searchlib/src/vespa/searchlib/docstore/filechunk.cpp
@@ -322,7 +322,7 @@ appendChunks(FixedParams * args, Chunk::UP chunk)
             if (args->db.getLid(args->lidReadGuard, e.getLid()) == lidInfo) {
                 // I am still in use so I need to taken care of.
                 vespalib::ConstBufferRef data(chunk->getLid(e.getLid()));
-                args->dest.write(guard, chunk->getId(), e.getLid(), data.c_str(), data.size());
+                args->dest.write(std::move(guard), chunk->getId(), e.getLid(), data.c_str(), data.size());
             }
         }
     }
diff --git a/searchlib/src/vespa/searchlib/docstore/logdatastore.cpp b/searchlib/src/vespa/searchlib/docstore/logdatastore.cpp
index 1850db7b02b..6674952d202 100644
--- a/searchlib/src/vespa/searchlib/docstore/logdatastore.cpp
+++ b/searchlib/src/vespa/searchlib/docstore/logdatastore.cpp
@@ -179,14 +179,14 @@ LogDataStore::write(uint64_t serialNum, uint32_t lid, const void * buffer, size_
 {
     LockGuard guard(_updateLock);
     WriteableFileChunk & active = getActive(guard);
-    write(guard, active, serialNum,  lid, buffer, len);
+    write(std::move(guard), active, serialNum,  lid, buffer, len);
 }
 
 void
 LogDataStore::write(LockGuard guard, FileId destinationFileId, uint32_t lid, const void * buffer, size_t len)
 {
     WriteableFileChunk & destination = static_cast<WriteableFileChunk &>(*_fileChunks[destinationFileId.getId()]);
-    write(guard, destination, destination.getSerialNum(), lid, buffer, len);
+    write(std::move(guard), destination, destination.getSerialNum(), lid, buffer, len);
 }
 
 void
@@ -196,7 +196,7 @@ LogDataStore::write(LockGuard guard, WriteableFileChunk & destination,
     LidInfo lm = destination.append(serialNum, lid, buffer, len);
     setLid(guard, lid, lm);
     if (destination.getFileId() == getActiveFileId(guard)) {
-        requireSpace(guard, destination);
+        requireSpace(std::move(guard), destination);
     }
 }
 
@@ -428,7 +428,7 @@ SerialNum LogDataStore::flushFile(LockGuard guard, WriteableFileChunk & file, Se
 }
 
 void LogDataStore::flushFileAndWait(LockGuard guard, WriteableFileChunk & file, SerialNum syncToken) {
-    syncToken = flushFile(guard, file, syncToken);
+    syncToken = flushFile(std::move(guard), file, syncToken);
     file.waitForDiskToCatchUpToNow();
     _tlSyncer.sync(syncToken);
     file.flushPendingChunks(syncToken);
@@ -437,13 +437,13 @@ void LogDataStore::flushFileAndWait(LockGuard guard, WriteableFileChunk & file,
 SerialNum LogDataStore::flushActive(SerialNum syncToken) {
     LockGuard guard(_updateLock);
     WriteableFileChunk &active = getActive(guard);
-    return flushFile(guard, active, syncToken);
+    return flushFile(std::move(guard), active, syncToken);
 }
 
 void LogDataStore::flushActiveAndWait(SerialNum syncToken) {
     LockGuard guard(_updateLock);
     WriteableFileChunk &active = getActive(guard);
-    return flushFileAndWait(guard, active, syncToken);
+    return flushFileAndWait(std::move(guard), active, syncToken);
 }
 
 bool LogDataStore::shouldCompactToActiveFile(size_t compactedSize) const {
@@ -488,7 +488,7 @@ void LogDataStore::compactFile(FileId fileId)
     } else {
         LockGuard guard(_updateLock);
         WriteableFileChunk & compactTo = dynamic_cast<WriteableFileChunk &>(*_fileChunks[destinationFileId.getId()]);
-        flushFileAndWait(guard, compactTo, 0);
+        flushFileAndWait(std::move(guard), compactTo, 0);
         compactTo.freeze();
     }
     compacter.reset();
diff --git a/vespalib/src/tests/sync/sync_test.cpp b/vespalib/src/tests/sync/sync_test.cpp
index ba6be74be22..a17f9089877 100644
--- a/vespalib/src/tests/sync/sync_test.cpp
+++ b/vespalib/src/tests/sync/sync_test.cpp
@@ -156,7 +156,7 @@ Test::Main()
         TryLock a(lock);
         CHECK_LOCKED(lock);
         if (a.hasLock()) {
-            LockGuard guard(a);
+            LockGuard guard(std::move(a));
             CHECK_LOCKED(lock);
         }
         CHECK_UNLOCKED(lock);
@@ -167,7 +167,7 @@ Test::Main()
         TryLock a(mon);
         CHECK_LOCKED(mon);
         if (a.hasLock()) {
-            LockGuard guard(a);
+            LockGuard guard(std::move(a));
             CHECK_LOCKED(mon);
         }
         CHECK_UNLOCKED(mon);
@@ -178,7 +178,7 @@ Test::Main()
         TryLock a(mon);
         CHECK_LOCKED(mon);
         if (a.hasLock()) {
-            MonitorGuard guard(a);
+            MonitorGuard guard(std::move(a));
             CHECK_LOCKED(mon);
         }
         CHECK_UNLOCKED(mon);
@@ -197,7 +197,7 @@ Test::Main()
         {
             CHECK_LOCKED(lock);
             EXPECT_TRUE(a.hasLock());
-            LockGuard guard(a);
+            LockGuard guard(std::move(a));
             EXPECT_TRUE(!a.hasLock());
             CHECK_LOCKED(lock);
         }
@@ -240,7 +240,7 @@ Test::Main()
         tl.unlock();
         EXPECT_FALSE(tl.hasLock());
     }
-    // LockGuard/MonitorGuard have destructive copy
+    // LockGuard/MonitorGuard have destructive move
     {
         Lock lock;
         CHECK_UNLOCKED(lock);
@@ -248,7 +248,7 @@ Test::Main()
         CHECK_LOCKED(lock);
         {
             CHECK_LOCKED(lock);
-            LockGuard b(a);
+            LockGuard b(std::move(a));
             CHECK_LOCKED(lock);
         }
         CHECK_UNLOCKED(lock);
@@ -260,7 +260,7 @@ Test::Main()
         CHECK_LOCKED(mon);
         {
             CHECK_LOCKED(mon);
-            MonitorGuard b(a);
+            MonitorGuard b(std::move(a));
             CHECK_LOCKED(mon);
         }
         CHECK_UNLOCKED(mon);
diff --git a/vespalib/src/vespa/vespalib/util/sync.h b/vespalib/src/vespa/vespalib/util/sync.h
index 86e0a227c72..c3d8ea86aec 100644
--- a/vespalib/src/vespa/vespalib/util/sync.h
+++ b/vespalib/src/vespa/vespalib/util/sync.h
@@ -2,39 +2,15 @@
 
 #pragma once
 
-#include <vespa/fastos/mutex.h>
-#include <vespa/fastos/cond.h>
 #include <vespa/fastos/time.h>
 #include <cassert>
+#include <mutex>
+#include <condition_variable>
+#include <chrono>
 
 
 namespace vespalib {
 
-#ifndef IAM_DOXYGEN
-class LockGuardHandover
-{
-private:
-    friend class LockGuard;
-    FastOS_MutexInterface *_mutex;
-    LockGuardHandover(const LockGuardHandover &);
-    LockGuardHandover &operator=(const LockGuardHandover &);
-    LockGuardHandover(FastOS_MutexInterface *m) : _mutex(m) {}
-public:
-};
-
-
-class MonitorGuardHandover
-{
-private:
-    friend class MonitorGuard;
-    FastOS_CondInterface *_cond;
-    MonitorGuardHandover(const MonitorGuardHandover &);
-    MonitorGuardHandover &operator=(const MonitorGuardHandover &);
-    MonitorGuardHandover(FastOS_CondInterface *c) : _cond(c) {}
-public:
-};
-#endif
-
 /**
  * @brief A Lock is a synchronization primitive used to ensure mutual
  * exclusion.
@@ -47,11 +23,11 @@ public:
  **/
 class Lock
 {
-private:
+protected:
     friend class LockGuard;
     friend class TryLock;
 
-    mutable FastOS_Mutex _mutex;
+    mutable std::mutex _mutex;
 public:
     /**
      * @brief Create a new Lock.
@@ -59,42 +35,10 @@ public:
      * Creates a Lock that has mutex instrumentation disabled.
      **/
     Lock() : _mutex() {}
-    /**
-     * @brief Create a new Lock.
-     *
-     * Creates a Lock with support for mutex instrumentation.
-     *
-     * @param name mutex category (for instrumentation)
-     * @param leaf false if you will lock other locks while holding this one,
-     *             true if you only lock this as the last (leaf) lock
-     *             (for instrumentation).
-     **/
-    Lock(const char *name, bool leaf) : _mutex() {(void) name; (void) leaf; }
-    /**
-     * @brief Copy a Lock.
-     *
-     * Create a new Lock with mutex instrumentation settings obtained
-     * from the given lock. No other information is copied.  Normally
-     * only used when copy-constructing a bigger object containing a
-     * Lock.
-     *
-     * @param rhs other Lock
-     **/
-    Lock(const Lock &rhs) : _mutex() { (void) rhs; }
-    /**
-     * @brief No-op assignment operator.
-     *
-     * Assignment operator ignoring the right hand side. It makes no
-     * sense to assign the state of one Lock to another, but we want
-     * to allow assignment of bigger objects that contain Lock
-     * objects.
-     *
-     * @param rhs other Lock (right hand side)
-     **/
-    Lock &operator=(const Lock &rhs) {
-        (void) rhs;
-        return *this;
-    }
+    Lock(const Lock &) : Lock() { }
+    Lock(Lock &&) : Lock() { }
+    Lock &operator=(const Lock &) { return *this; }
+    Lock &operator=(Lock &&) { return *this; }
 };
 
 
@@ -110,56 +54,25 @@ public:
  *
  * @see TryLock
  **/
-class Monitor
+class Monitor : public Lock
 {
 private:
     friend class LockGuard;
     friend class MonitorGuard;
     friend class TryLock;
 
-    mutable FastOS_Cond _cond;
+    mutable std::condition_variable _cond;
 public:
     /**
      * @brief Create a new Monitor.
      *
      * Creates a Monitor that has mutex instrumentation disabled.
      **/
-    Monitor() : _cond() {}
-    /**
-     * @brief Create a new Monitor.
-     *
-     * Creates a Monitor with support for mutex instrumentation.
-     *
-     * @param name mutex category (for instrumentation)
-     * @param leaf false if you will lock other locks while holding this one,
-     *             true if you only lock this as the last (leaf) lock
-     *             (for instrumentation).
-     **/
-    Monitor(const char *name, bool leaf) : _cond() { (void) name; (void) leaf; }
-    /**
-     * @brief Copy a Monitor.
-     *
-     * Creates a new Monitor with mutex instrumentation settings
-     * obtained from the given monitor. No other information is
-     * copied.  Normally only used when copy-constructing a bigger
-     * object containing a Lock.
-     *
-     * @param rhs other Monitor
-     **/
-    Monitor(const Monitor &rhs) : _cond() { (void) rhs; }
-    /**
-     * @brief No-op assignment operator.
-     *
-     * Assignment operator ignoring the right hand side. It makes no
-     * sense to assign the state of one Monitor to another, but we want
-     * to allow assigning objects that contain Monitor objects.
-     *
-     * @param rhs other Monitor (right hand side)
-     **/
-    Monitor &operator=(const Monitor &rhs) {
-        (void) rhs;
-        return *this;
-    }
+    Monitor() : Lock(), _cond() {}
+    Monitor(const Monitor &) : Monitor() { }
+    Monitor(Monitor &&) : Monitor() { }
+    Monitor &operator=(const Monitor &) { return *this; }
+    Monitor &operator=(Monitor &&) { return *this; }
 };
 
 
@@ -198,29 +111,11 @@ private:
     friend class LockGuard;
     friend class MonitorGuard;
 
-    FastOS_MutexInterface *_mutex;
-    FastOS_CondInterface  *_cond;
-
-    TryLock(const TryLock &);
-    TryLock &operator=(const TryLock &);
+    std::unique_lock<std::mutex> _guard;
+    std::condition_variable     *_cond;
 
-    FastOS_MutexInterface *stealMutex() {
-        FastOS_MutexInterface *ret = _mutex;
-        if (ret != NULL) {
-            _mutex = NULL;
-            return ret;
-        }
-        ret = _cond;
-        assert(ret != NULL);
-        _cond = NULL;
-        return ret;
-    }
-    FastOS_CondInterface *stealCond() {
-        FastOS_CondInterface *ret = _cond;
-        assert(ret != NULL);
-        _cond = NULL;
-        return ret;
-    }
+    TryLock(const TryLock &) = delete;
+    TryLock &operator=(const TryLock &) = delete;
 
 public:
     /**
@@ -228,38 +123,50 @@ public:
      *
      * @param lock the lock to obtain
      **/
-    TryLock(const Lock &lock) : _mutex(&lock._mutex), _cond(NULL) {
-        if (!_mutex->TryLock()) {
-            _mutex = NULL;
-        }
+    TryLock(const Lock &lock)
+        : _guard(lock._mutex, std::try_to_lock),
+          _cond(nullptr)
+    {
     }
+
     /**
      * @brief Try to lock the given Monitor
      *
      * @param mon the monitor to lock
      **/
-    TryLock(const Monitor &mon) : _mutex(NULL), _cond(&mon._cond) {
-        if (!_cond->TryLock()) {
-            _cond = NULL;
-        }
+    TryLock(const Monitor &mon)
+        : _guard(mon._mutex, std::try_to_lock),
+          _cond(_guard ? &mon._cond : nullptr)
+    {
+    }
+
+    TryLock(TryLock &&rhs)
+        : _guard(std::move(rhs._guard)),
+          _cond(rhs._cond)
+    {
+        rhs._cond = nullptr;
     }
+
     /**
      * @brief Release the lock held by this object, if any
      **/
-    ~TryLock() {
-        if (_mutex != NULL) {
-            _mutex->Unlock();
-        }
-        if (_cond != NULL) {
-            _cond->Unlock();
+    ~TryLock() = default;
+
+    TryLock &operator=(TryLock &&rhs) {
+        if (this != &rhs) {
+            _guard = std::move(rhs._guard);
+            _cond = rhs._cond;
+            rhs._cond = nullptr;
         }
+        return *this;
     }
+
     /**
      * @brief Check whether this object holds a lock
      *
      * @return true if this object holds a lock
      **/
-    bool hasLock() { return (_mutex != NULL || _cond != NULL); }
+    bool hasLock() { return static_cast<bool>(_guard); }
     /**
      * @brief Release the lock held by this object.
      *
@@ -269,13 +176,9 @@ public:
      * the destructor will release the lock.
      **/
     void unlock() {
-        if (_mutex != NULL) {
-            _mutex->Unlock();
-            _mutex = NULL;
-        }
-        if (_cond != NULL) {
-            _cond->Unlock();
-            _cond = NULL;
+        if (_guard) {
+            _guard.unlock();
+            _cond = nullptr;
         }
     }
 };
@@ -296,25 +199,20 @@ public:
 class LockGuard
 {
 private:
-    FastOS_MutexInterface *_mutex;
-    LockGuard &operator=(const LockGuard &);
-
-    FastOS_MutexInterface *stealMutex() {
-        FastOS_MutexInterface *ret = _mutex;
-        _mutex = NULL;
-        return ret;
-    }
+    std::unique_lock<std::mutex> _guard;
+    LockGuard &operator=(const LockGuard &) = delete;
 public:
     /**
      * @brief A noop guard without any mutex.
      **/
-    LockGuard() : _mutex(NULL) {}
+    LockGuard() : _guard() {}
+    LockGuard(const LockGuard &rhs) = delete;
     /**
      * @brief Steal the lock from the given LockGuard
      *
      * @param rhs steal the lock from this one
      **/
-    LockGuard(LockGuard &rhs) : _mutex(rhs.stealMutex()) {}
+    LockGuard(LockGuard &&rhs) : _guard(std::move(rhs._guard)) { }
     /**
      * @brief Obtain the lock represented by the given Lock object.
      *
@@ -322,19 +220,8 @@ public:
      *
      * @param lock take it
      **/
-    LockGuard(const Lock &lock) : _mutex(&lock._mutex) {
-        _mutex->Lock();
-    }
-    /**
-     * @brief Obtain the lock on the given Monitor object.
-     *
-     * The method will block until the lock can be obtained.
-     *
-     * @param monitor take the lock on it
-     **/
-    LockGuard(const Monitor &monitor) : _mutex(&monitor._cond) {
-        _mutex->Lock();
-    }
+    LockGuard(const Lock &lock) : _guard(lock._mutex) { }
+
     /**
      * @brief Create a LockGuard from a TryLock.
      *
@@ -344,11 +231,18 @@ public:
      *
      * @param tlock take the lock from this one
      **/
-    LockGuard(TryLock &tlock) : _mutex(tlock.stealMutex()) {}
-#ifndef IAM_DOXYGEN
-    LockGuard(const LockGuardHandover &rhs) : _mutex(rhs._mutex) {}
-    operator LockGuardHandover() { return LockGuardHandover(stealMutex()); }
-#endif
+    LockGuard(TryLock &&tlock) : _guard(std::move(tlock._guard))
+    {
+        tlock._cond = nullptr;
+    }
+
+    LockGuard &operator=(LockGuard &&rhs) {
+        if (this != &rhs) {
+            _guard = std::move(rhs._guard);
+        }
+        return *this;
+    }
+
     /**
      * @brief Release the lock held by this object.
      *
@@ -358,27 +252,22 @@ public:
      * the destructor will release the lock.
      **/
     void unlock() {
-        if (_mutex != NULL) {
-            _mutex->Unlock();
-            _mutex = NULL;
+        if (_guard) {
+            _guard.unlock();
         }
     }
     /**
      * @brief Release the lock held by this object if unlock has not
      * been called.
      **/
-    ~LockGuard() {
-        if (_mutex != NULL) {
-            _mutex->Unlock();
-        }
-    }
+    ~LockGuard() = default;
 
     /**
      * Allow code to match guard with lock. This allows functions to take a
      * guard ref as input, ensuring that the caller have grabbed a lock.
      */
     bool locks(const Lock& lock) const {
-        return (_mutex != NULL && _mutex == &lock._mutex);
+        return (_guard && _guard.mutex() == &lock._mutex);
     }
 };
 
@@ -399,25 +288,27 @@ public:
 class MonitorGuard
 {
 private:
-    FastOS_CondInterface *_cond;
-    MonitorGuard &operator=(const MonitorGuard &);
+    std::unique_lock<std::mutex> _guard;
+    std::condition_variable *_cond;
+    MonitorGuard &operator=(const MonitorGuard &) = delete;
 
-    FastOS_CondInterface *stealCond() {
-        FastOS_CondInterface *ret = _cond;
-        _cond = NULL;
-        return ret;
-    }
 public:
     /**
      * @brief A noop guard without any condition.
      **/
-    MonitorGuard() : _cond(NULL) {}
+    MonitorGuard() : _guard(), _cond(nullptr) {}
+    MonitorGuard(const MonitorGuard &rhs) = delete;
     /**
      * @brief Steal the lock from the given MonitorGuard
      *
      * @param rhs steal the lock from this one
      **/
-    MonitorGuard(MonitorGuard &rhs) : _cond(rhs.stealCond()) {}
+    MonitorGuard(MonitorGuard &&rhs)
+        : _guard(std::move(rhs._guard)),
+          _cond(rhs._cond)
+    {
+        rhs._cond = nullptr;
+    }
     /**
      * @brief Obtain the lock on the given Monitor object.
      *
@@ -425,8 +316,10 @@ public:
      *
      * @param monitor take the lock on it
      **/
-    MonitorGuard(const Monitor &monitor) : _cond(&monitor._cond) {
-        _cond->Lock();
+    MonitorGuard(const Monitor &monitor)
+        : _guard(monitor._mutex),
+          _cond(&monitor._cond)
+    {
     }
     /**
      * @brief Create a MonitorGuard from a TryLock.
@@ -437,13 +330,27 @@ public:
      *
      * @param tlock take the lock from this one
      **/
-    MonitorGuard(TryLock &tlock) : _cond(tlock.stealCond()) {}
-#ifndef IAM_DOXYGEN
-    MonitorGuard(const MonitorGuardHandover &rhs) : _cond(rhs._cond) {}
-    operator MonitorGuardHandover() {
-        return MonitorGuardHandover(stealCond());
+    MonitorGuard(TryLock &&tlock)
+        : _guard(),
+          _cond(nullptr)
+    {
+        if (tlock._guard && tlock._cond != nullptr) {
+            _guard = std::move(tlock._guard);
+            _cond = tlock._cond;
+            tlock._cond = nullptr;
+        }
+    }
+
+    MonitorGuard &operator=(MonitorGuard &&rhs) {
+        if (this != &rhs) {
+            _guard = std::move(rhs._guard);
+            _cond = rhs._cond;
+            rhs._cond = nullptr;
+        }
+        return *this;
     }
-#endif
+
+
     /**
      * @brief Release the lock held by this object.
      *
@@ -453,8 +360,8 @@ public:
      * the destructor will release the lock.
      **/
     void unlock() {
-        assert(_cond != NULL);
-        _cond->Unlock();
+        assert(_guard);
+        _guard.unlock();
         _cond = NULL;
     }
     /**
@@ -462,7 +369,7 @@ public:
      **/
     void wait() {
         assert(_cond != NULL);
-        _cond->Wait();
+        _cond->wait(_guard);
     }
     /**
      * @brief Wait for a signal on the underlying Monitor with the
@@ -473,7 +380,7 @@ public:
      **/
     bool wait(int msTimeout) {
         assert(_cond != NULL);
-        return _cond->TimedWait(msTimeout);
+        return _cond->wait_for(_guard, std::chrono::milliseconds(msTimeout)) == std::cv_status::no_timeout;
     }
     /**
      * @brief Send a signal to a single waiter on the underlying
@@ -481,14 +388,14 @@ public:
      **/
     void signal() {
         assert(_cond != NULL);
-        _cond->Signal();
+        _cond->notify_one();
     }
     /**
      * @brief Send a signal to all waiters on the underlying Monitor.
      **/
     void broadcast() {
         assert(_cond != NULL);
-        _cond->Broadcast();
+        _cond->notify_all();
     }
     /**
      * @brief Send a signal to a single waiter on the underlying
@@ -500,8 +407,8 @@ public:
      **/
     void unsafeSignalUnlock() {
         assert(_cond != NULL);
-        _cond->Unlock();
-        _cond->Signal();
+        _guard.unlock();
+        _cond->notify_one();
         _cond = NULL;
     }
     /**
@@ -514,19 +421,15 @@ public:
      **/
     void unsafeBroadcastUnlock() {
         assert(_cond != NULL);
-        _cond->Unlock();
-        _cond->Broadcast();
+        _guard.unlock();
+        _cond->notify_all();
         _cond = NULL;
     }
     /**
      * @brief Release the lock held by this object if unlock has not
      * been called.
      **/
-    ~MonitorGuard() {
-        if (_cond != NULL) {
-            _cond->Unlock();
-        }
-    }
+    ~MonitorGuard() = default;
 
     /**
      * Allow code to match guard with lock. This allows functions to take a
@@ -642,8 +545,8 @@ private:
     Monitor  _monitor;
     uint32_t _count;
 
-    CountDownLatch(const CountDownLatch &rhs);
-    CountDownLatch &operator=(const CountDownLatch &rhs);
+    CountDownLatch(const CountDownLatch &rhs) = delete;
+    CountDownLatch &operator=(const CountDownLatch &rhs) = delete;
 
 public:
     /**