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, 7 insertions, 8 deletions

diff --git a/host/lib/usrp/b100/usb_zero_copy_wrapper.cpp b/host/lib/usrp/b100/usb_zero_copy_wrapper.cpp
index b2348c3a9..7596b47be 100644
--- a/host/lib/usrp/b100/usb_zero_copy_wrapper.cpp
+++ b/host/lib/usrp/b100/usb_zero_copy_wrapper.cpp
@@ -11,11 +11,10 @@
 #include <uhd/utils/log.hpp>
 #include <uhd/utils/tasks.hpp>
 #include <uhdlib/utils/atomic.hpp>
-#include <boost/thread/condition_variable.hpp>
-#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition.hpp>
 #include <functional>
-#include <iostream>
 #include <memory>
+#include <mutex>
 #include <vector>
 
 using namespace uhd;
@@ -98,7 +97,7 @@ public:
 
     void release(void) override
     {
-        boost::mutex::scoped_lock lock(_mutex);
+        std::unique_lock<std::mutex> lock(_mutex);
         _ok_to_auto_flush = true;
 
         // get a reference to the VITA header before incrementing
@@ -124,7 +123,7 @@ public:
 
     UHD_INLINE sptr get_new(const double timeout)
     {
-        boost::mutex::scoped_lock lock(_mutex);
+        std::lock_guard<std::mutex> lock(_mutex);
         _ok_to_auto_flush = false;
 
         if (not _last_send_buff) {
@@ -146,8 +145,8 @@ private:
     char* _mem_buffer_tip;
 
     // private variables for auto flusher
-    boost::mutex _mutex;
-    boost::condition_variable _cond;
+    std::mutex _mutex;
+    boost::condition _cond;
     uhd::task::sptr _task;
     bool _ok_to_auto_flush;
 
@@ -157,7 +156,7 @@ private:
      */
     void auto_flush(void)
     {
-        boost::mutex::scoped_lock lock(_mutex);
+        std::unique_lock<std::mutex> lock(_mutex);
         const bool timeout = not _cond.timed_wait(lock, AUTOFLUSH_TIMEOUT);
         if (timeout and _ok_to_auto_flush and _last_send_buff and _bytes_in_buffer != 0) {
             _last_send_buff->commit(_bytes_in_buffer);