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.

7 files changed, 34 insertions, 34 deletions

diff --git a/host/lib/transport/libusb1_base.cpp b/host/lib/transport/libusb1_base.cpp
index df6ed45eb..6808a3e0d 100644
--- a/host/lib/transport/libusb1_base.cpp
+++ b/host/lib/transport/libusb1_base.cpp
@@ -11,7 +11,6 @@
 #include <uhd/types/serial.hpp>
 #include <uhd/utils/log.hpp>
 #include <uhd/utils/tasks.hpp>
-#include <boost/thread/mutex.hpp>
 #include <cstdlib>
 #include <functional>
 #include <iostream>
@@ -353,8 +352,8 @@ libusb::device_handle::sptr libusb::device_handle::get_cached_handle(device::spt
     static uhd::dict<libusb_device*, std::weak_ptr<device_handle>> handles;
 
     // lock for atomic access to static table above
-    static boost::mutex mutex;
-    boost::mutex::scoped_lock lock(mutex);
+    static std::mutex mutex;
+    std::lock_guard<std::mutex> lock(mutex);
 
     // not expired -> get existing handle
     if (handles.has_key(dev->get()) and not handles[dev->get()].expired()) {
diff --git a/host/lib/transport/libusb1_control.cpp b/host/lib/transport/libusb1_control.cpp
index e6339e17f..5d49e3931 100644
--- a/host/lib/transport/libusb1_control.cpp
+++ b/host/lib/transport/libusb1_control.cpp
@@ -7,7 +7,7 @@
 
 #include "libusb1_base.hpp"
 #include <uhd/transport/usb_control.hpp>
-#include <boost/thread/mutex.hpp>
+#include <mutex>
 
 using namespace uhd::transport;
 
@@ -38,7 +38,7 @@ public:
         uint16_t length,
         uint32_t libusb_timeout = 0) override
     {
-        boost::mutex::scoped_lock lock(_mutex);
+        std::lock_guard<std::mutex> lock(_mutex);
         return libusb_control_transfer(_handle->get(),
             request_type,
             request,
@@ -51,7 +51,7 @@ public:
 
 private:
     libusb::device_handle::sptr _handle;
-    boost::mutex _mutex;
+    std::mutex _mutex;
 };
 
 libusb_control_impl::~libusb_control_impl(void)
diff --git a/host/lib/transport/libusb1_zero_copy.cpp b/host/lib/transport/libusb1_zero_copy.cpp
index fc36b36b7..fe33d2068 100644
--- a/host/lib/transport/libusb1_zero_copy.cpp
+++ b/host/lib/transport/libusb1_zero_copy.cpp
@@ -14,11 +14,11 @@
 #include <uhd/utils/log.hpp>
 #include <boost/circular_buffer.hpp>
 #include <boost/format.hpp>
-#include <boost/thread/condition_variable.hpp>
-#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition.hpp>
 #include <functional>
 #include <list>
 #include <memory>
+#include <mutex>
 
 using namespace uhd;
 using namespace uhd::transport;
@@ -49,8 +49,8 @@ struct lut_result_t
     int completed;
     libusb_transfer_status status;
     int actual_length;
-    boost::mutex mut;
-    boost::condition_variable usb_transfer_complete;
+    std::mutex mut;
+    boost::condition usb_transfer_complete;
 
 #ifdef UHD_TXRX_DEBUG_PRINTS
     // These are fore debugging
@@ -89,7 +89,7 @@ static void libusb1_zerocopy_dbg_print_err(std::string msg)
 static void LIBUSB_CALL libusb_async_cb(libusb_transfer* lut)
 {
     lut_result_t* r = (lut_result_t*)lut->user_data;
-    boost::lock_guard<boost::mutex> lock(r->mut);
+    std::lock_guard<std::mutex> lock(r->mut);
     r->status        = lut->status;
     r->actual_length = lut->actual_length;
     r->completed     = 1;
@@ -179,7 +179,7 @@ public:
      */
     UHD_INLINE bool wait_for_completion(const double timeout)
     {
-        boost::unique_lock<boost::mutex> lock(result.mut);
+        std::unique_lock<std::mutex> lock(result.mut);
         if (!result.completed) {
             if (timeout < 0.0) {
                 result.usb_transfer_complete.wait(lock);
@@ -313,9 +313,9 @@ public:
             return buff;
 
         // Serialize access to buffers
-        boost::mutex::scoped_lock get_buff_lock(_get_buff_mutex);
+        std::lock_guard<std::mutex> get_buff_lock(_get_buff_mutex);
 
-        boost::mutex::scoped_lock queue_lock(_queue_mutex);
+        std::unique_lock<std::mutex> queue_lock(_queue_mutex);
         if (_enqueued.empty()) {
             _buff_ready_cond.timed_wait(
                 queue_lock, boost::posix_time::microseconds(long(timeout * 1e6)));
@@ -351,9 +351,9 @@ private:
     buffer_pool::sptr _buffer_pool;
     std::vector<std::shared_ptr<libusb_zero_copy_mb>> _mb_pool;
 
-    boost::mutex _queue_mutex;
-    boost::condition_variable _buff_ready_cond;
-    boost::mutex _get_buff_mutex;
+    std::mutex _queue_mutex;
+    boost::condition _buff_ready_cond;
+    std::mutex _get_buff_mutex;
 
     //! why 2 queues? there is room in the future to have > N buffers but only N in flight
     boost::circular_buffer<libusb_zero_copy_mb*> _enqueued, _released;
@@ -362,7 +362,7 @@ private:
 
     void enqueue_buffer(libusb_zero_copy_mb* mb)
     {
-        boost::mutex::scoped_lock l(_queue_mutex);
+        std::lock_guard<std::mutex> l(_queue_mutex);
         _released.push_back(mb);
         this->submit_what_we_can();
         _buff_ready_cond.notify_one();
@@ -416,13 +416,13 @@ struct libusb_zero_copy_impl : usb_zero_copy
 
     managed_recv_buffer::sptr get_recv_buff(double timeout) override
     {
-        boost::mutex::scoped_lock l(_recv_mutex);
+        std::lock_guard<std::mutex> l(_recv_mutex);
         return _recv_impl->get_buff<managed_recv_buffer>(timeout);
     }
 
     managed_send_buffer::sptr get_send_buff(double timeout) override
     {
-        boost::mutex::scoped_lock l(_send_mutex);
+        std::lock_guard<std::mutex> l(_send_mutex);
         return _send_impl->get_buff<managed_send_buffer>(timeout);
     }
 
@@ -445,7 +445,7 @@ struct libusb_zero_copy_impl : usb_zero_copy
     }
 
     std::shared_ptr<libusb_zero_copy_single> _recv_impl, _send_impl;
-    boost::mutex _recv_mutex, _send_mutex;
+    std::mutex _recv_mutex, _send_mutex;
 };
 
 libusb_zero_copy_impl::~libusb_zero_copy_impl(void)
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,
diff --git a/host/lib/transport/nirio/niusrprio_session.cpp b/host/lib/transport/nirio/niusrprio_session.cpp
index b2ea659df..00838075f 100644
--- a/host/lib/transport/nirio/niusrprio_session.cpp
+++ b/host/lib/transport/nirio/niusrprio_session.cpp
@@ -51,7 +51,7 @@ nirio_status niusrprio_session::enumerate(
 
 nirio_status niusrprio_session::open(nifpga_lvbitx::sptr lvbitx, bool force_download)
 {
-    boost::unique_lock<boost::recursive_mutex> lock(_session_mutex);
+    std::unique_lock<std::recursive_mutex> lock(_session_mutex);
 
     _lvbitx = lvbitx;
 
@@ -101,7 +101,7 @@ nirio_status niusrprio_session::open(nifpga_lvbitx::sptr lvbitx, bool force_down
 
 void niusrprio_session::close(bool skip_reset)
 {
-    boost::unique_lock<boost::recursive_mutex> lock(_session_mutex);
+    std::unique_lock<std::recursive_mutex> lock(_session_mutex);
 
     if (_session_open) {
         nirio_status status = NiRio_Status_Success;
@@ -114,14 +114,14 @@ void niusrprio_session::close(bool skip_reset)
 
 nirio_status niusrprio_session::reset()
 {
-    boost::unique_lock<boost::recursive_mutex> lock(_session_mutex);
+    std::unique_lock<std::recursive_mutex> lock(_session_mutex);
     return _rpc_client.niusrprio_reset_device(_resource_name);
 }
 
 nirio_status niusrprio_session::download_bitstream_to_flash(
     const std::string& bitstream_path)
 {
-    boost::unique_lock<boost::recursive_mutex> lock(_session_mutex);
+    std::unique_lock<std::recursive_mutex> lock(_session_mutex);
     return _rpc_client.niusrprio_download_fpga_to_flash(_resource_name, bitstream_path);
 }
 
diff --git a/host/lib/transport/nirio/rpc/rpc_client.cpp b/host/lib/transport/nirio/rpc/rpc_client.cpp
index 661f72e81..7b5970610 100644
--- a/host/lib/transport/nirio/rpc/rpc_client.cpp
+++ b/host/lib/transport/nirio/rpc/rpc_client.cpp
@@ -109,7 +109,7 @@ const boost::system::error_code& rpc_client::call(func_id_t func_id,
     func_args_reader_t& out_args,
     boost::posix_time::milliseconds timeout)
 {
-    boost::mutex::scoped_lock lock(_mutex);
+    std::unique_lock<std::mutex> lock(_mutex);
 
     if (_io_service_thread.get()) {
         _request.header.func_id = func_id;
@@ -168,7 +168,7 @@ const boost::system::error_code& rpc_client::call(func_id_t func_id,
 void rpc_client::_handle_response_hdr(
     const boost::system::error_code& err, size_t transferred, size_t expected)
 {
-    boost::mutex::scoped_lock lock(_mutex);
+    std::lock_guard<std::mutex> lock(_mutex);
     _exec_err = err;
     if (!_exec_err && (transferred == expected)) {
         // Response header received. Verify that it is expected
@@ -205,7 +205,7 @@ void rpc_client::_handle_response_hdr(
 void rpc_client::_handle_response_data(
     const boost::system::error_code& err, size_t transferred, size_t expected)
 {
-    boost::mutex::scoped_lock lock(_mutex);
+    std::lock_guard<std::mutex> lock(_mutex);
     _exec_err = err;
     if (transferred != expected) {
         _exec_err.assign(boost::asio::error::operation_aborted,
diff --git a/host/lib/transport/nirio_link.cpp b/host/lib/transport/nirio_link.cpp
index 28883ead0..b354aa377 100644
--- a/host/lib/transport/nirio_link.cpp
+++ b/host/lib/transport/nirio_link.cpp
@@ -9,6 +9,7 @@
 #include <uhdlib/transport/adapter.hpp>
 #include <uhdlib/transport/links.hpp>
 #include <uhdlib/transport/nirio_link.hpp>
+#include <boost/format.hpp>
 #include <chrono>
 
 // X300 regs