uhd: Replace Boost mutexes and locks with standard options

This is a very mechanical task that could almost have been done with
sed. Boost versions of mutexes and locks were removed, and replaced with
std:: versions. The replacement tables are as follows:

== Mutexes ==
- boost::mutex -> std::mutex
- boost::recursive_mutex -> std::recursive_mutex

Mutexes behave identically between Boost and std:: and have the same
API.

== Locks ==
C++11 has only two types of lock that we use/need in UHD:
- std::lock_guard: Identical to boost::lock_guard
- std::unique_lock: Identical to boost::unique_lock

Boost also has boost::mutex::scoped_lock, which is a typedef for
boost::unique_lock<>. However, we often have used scoped_lock where we
meant to use lock_guard<>. The name is a bit misleading, "scoped lock"
sounding a bit like an RAII mechanism. Therefore, some previous
boost::mutex::scoped_lock are now std::lock_guard<>.

std::unique_lock is required when doing more than RAII locking (i.e.,
unlocking, relocking, usage with condition variables, etc.).

== Condition Variables ==
Condition variables were out of the scope of this lock/mutex change, but
in UHD, we inconsistently use boost::condition vs.
boost::condition_variable. The former is a templated version of the
latter, and thus works fine with std::mutex'es. Therefore, some
boost::condition_variable where changed to boost::condition.

All locks and mutexes use `#include <mutex>`. The corresponding Boost
includes were removed. In some cases, this exposed issues with implicit
Boost includes elsewhere. The missing explicit includes were added.

3 files changed, 16 insertions, 16 deletions

diff --git a/host/lib/include/uhdlib/experts/expert_container.hpp b/host/lib/include/uhdlib/experts/expert_container.hpp
index bb05ae334..c794e9d8c 100644
--- a/host/lib/include/uhdlib/experts/expert_container.hpp
+++ b/host/lib/include/uhdlib/experts/expert_container.hpp
@@ -10,8 +10,8 @@
 #include <uhd/config.hpp>
 #include <uhd/utils/noncopyable.hpp>
 #include <uhdlib/experts/expert_nodes.hpp>
-#include <boost/thread/recursive_mutex.hpp>
 #include <memory>
+#include <mutex>
 
 namespace uhd { namespace experts {
 
@@ -153,7 +153,7 @@ private:
      * container.
      *
      */
-    virtual boost::recursive_mutex& resolve_mutex() = 0;
+    virtual std::recursive_mutex& resolve_mutex() = 0;
 
     /*!
      * Add a data node to the expert graph
diff --git a/host/lib/include/uhdlib/experts/expert_nodes.hpp b/host/lib/include/uhdlib/experts/expert_nodes.hpp
index ce061ca26..66dd0f246 100644
--- a/host/lib/include/uhdlib/experts/expert_nodes.hpp
+++ b/host/lib/include/uhdlib/experts/expert_nodes.hpp
@@ -14,11 +14,12 @@
 #include <uhd/utils/noncopyable.hpp>
 #include <stdint.h>
 #include <boost/core/demangle.hpp>
-#include <boost/thread.hpp>
-#include <boost/thread/recursive_mutex.hpp>
 #include <functional>
 #include <list>
 #include <memory>
+#include <mutex>
+#include <sstream>
+#include <thread>
 
 namespace uhd { namespace experts {
 
@@ -130,7 +131,7 @@ public:
     // from the outside world (of experts) using read and write callbacks. We
     // assume that if a callback mutex is passed into the data node that it will
     // be accessed from the outside and tag the data node as a PROPERTY.
-    data_node_t(const std::string& name, boost::recursive_mutex* mutex = NULL)
+    data_node_t(const std::string& name, std::recursive_mutex* mutex = NULL)
         : dag_vertex_t(mutex ? CLASS_PROPERTY : CLASS_DATA, name)
         , _callback_mutex(mutex)
         , _data()
@@ -138,9 +139,8 @@ public:
     {
     }
 
-    data_node_t(const std::string& name,
-        const data_t& value,
-        boost::recursive_mutex* mutex = NULL)
+    data_node_t(
+        const std::string& name, const data_t& value, std::recursive_mutex* mutex = NULL)
         : dag_vertex_t(mutex ? CLASS_PROPERTY : CLASS_DATA, name)
         , _callback_mutex(mutex)
         , _data(value)
@@ -199,7 +199,7 @@ public:
         if (_callback_mutex == NULL)
             throw uhd::assertion_error(
                 "node " + get_name() + " is missing the callback mutex");
-        boost::lock_guard<boost::recursive_mutex> lock(*_callback_mutex);
+        std::lock_guard<std::recursive_mutex> lock(*_callback_mutex);
         set(value);
         _author = AUTHOR_USER;
         if (is_dirty() and has_write_callback()) {
@@ -213,7 +213,7 @@ public:
         if (_callback_mutex == NULL)
             throw uhd::assertion_error(
                 "node " + get_name() + " is missing the callback mutex");
-        boost::lock_guard<boost::recursive_mutex> lock(*_callback_mutex);
+        std::lock_guard<std::recursive_mutex> lock(*_callback_mutex);
         if (has_read_callback()) {
             _rd_callback(std::string(get_name()));
         }
@@ -252,7 +252,7 @@ private:
         _rd_callback = nullptr;
     }
 
-    boost::recursive_mutex* _callback_mutex;
+    std::recursive_mutex* _callback_mutex;
     callback_func_t _rd_callback;
     callback_func_t _wr_callback;
     dirty_tracked<data_t> _data;
diff --git a/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer_3000.hpp b/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer_3000.hpp
index 0e1041642..7fa24f046 100644
--- a/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer_3000.hpp
+++ b/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer_3000.hpp
@@ -13,10 +13,10 @@
 #include <uhd/utils/byteswap.hpp>
 #include <uhd/utils/log.hpp>
 #include <stdint.h>
-#include <boost/thread.hpp>
 #include <chrono>
 #include <map>
 #include <memory>
+#include <mutex>
 #include <queue>
 
 namespace uhd { namespace usrp {
@@ -62,7 +62,7 @@ struct recv_packet_demuxer_3000 : std::enable_shared_from_this<recv_packet_demux
         //-- Check the queue to see if we already have a buffer
         //----------------------------------------------------------
         {
-            boost::mutex::scoped_lock l(mutex);
+            std::lock_guard<std::mutex> l(mutex);
             queue_type_t& queue = _queues[sid];
             if (not queue.empty()) {
                 buff = queue.front();
@@ -76,7 +76,7 @@ struct recv_packet_demuxer_3000 : std::enable_shared_from_this<recv_packet_demux
             if (buff) {
                 const uint32_t new_sid = uhd::wtohx(buff->cast<const uint32_t*>()[1]);
                 if (new_sid != sid) {
-                    boost::mutex::scoped_lock l(mutex);
+                    std::lock_guard<std::mutex> l(mutex);
                     if (_queues.count(new_sid) == 0)
                         UHD_LOGGER_ERROR("STREAMER")
                             << "recv packet demuxer unexpected sid 0x" << std::hex
@@ -92,7 +92,7 @@ struct recv_packet_demuxer_3000 : std::enable_shared_from_this<recv_packet_demux
 
     void realloc_sid(const uint32_t sid)
     {
-        boost::mutex::scoped_lock l(mutex);
+        std::lock_guard<std::mutex> l(mutex);
         while (not _queues[sid].empty()) // allocated and clears if already allocated
         {
             _queues[sid].pop();
@@ -104,7 +104,7 @@ struct recv_packet_demuxer_3000 : std::enable_shared_from_this<recv_packet_demux
     typedef std::queue<transport::managed_recv_buffer::sptr> queue_type_t;
     std::map<uint32_t, queue_type_t> _queues;
     transport::zero_copy_if::sptr _xport;
-    boost::mutex mutex;
+    std::mutex mutex;
 };
 
 struct recv_packet_demuxer_proxy_3000 : transport::zero_copy_if