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.

1 files changed, 6 insertions, 6 deletions

diff --git a/host/lib/transport/muxed_zero_copy_if.cpp b/host/lib/transport/muxed_zero_copy_if.cpp
index f7cc88c9c..34407a9ff 100644
--- a/host/lib/transport/muxed_zero_copy_if.cpp
+++ b/host/lib/transport/muxed_zero_copy_if.cpp
@@ -10,10 +10,10 @@
 #include <uhd/transport/muxed_zero_copy_if.hpp>
 #include <uhd/utils/safe_call.hpp>
 #include <boost/thread.hpp>
-#include <boost/thread/locks.hpp>
 #include <functional>
 #include <map>
 #include <memory>
+#include <mutex>
 
 using namespace uhd;
 using namespace uhd::transport;
@@ -60,7 +60,7 @@ public:
 
     zero_copy_if::sptr make_stream(const uint32_t stream_num) override
     {
-        boost::lock_guard<boost::mutex> lock(_mutex);
+        std::lock_guard<std::mutex> lock(_mutex);
         if (_streams.size() >= _max_num_streams) {
             throw uhd::runtime_error("muxed_zero_copy_if: stream capacity exceeded. "
                                      "cannot create more streams.");
@@ -82,7 +82,7 @@ public:
 
     void remove_stream(const uint32_t stream_num) override
     {
-        boost::lock_guard<boost::mutex> lock(_mutex);
+        std::lock_guard<std::mutex> lock(_mutex);
         _streams.erase(stream_num);
     }
 
@@ -256,7 +256,7 @@ private:
                 {
                     // Hold the stream mutex long enough to pull a bounded buffer
                     // and lock it (increment its ref count).
-                    boost::lock_guard<boost::mutex> lock(_mutex);
+                    std::lock_guard<std::mutex> lock(_mutex);
                     stream_map_t::iterator str_iter = _streams.find(stream_num);
                     if (str_iter != _streams.end()) {
                         stream = (*str_iter).second.lock();
@@ -270,7 +270,7 @@ private:
             if (stream.get()) {
                 stream->push_recv_buff(buff);
             } else {
-                boost::lock_guard<boost::mutex> lock(_mutex);
+                std::lock_guard<std::mutex> lock(_mutex);
                 _num_dropped_frames++;
             }
             // We processed a packet, and there could be more coming
@@ -291,7 +291,7 @@ private:
     const size_t _max_num_streams;
     size_t _num_dropped_frames;
     boost::thread _recv_thread;
-    boost::mutex _mutex;
+    std::mutex _mutex;
 };
 
 muxed_zero_copy_if::sptr muxed_zero_copy_if::make(zero_copy_if::sptr base_xport,