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

diff --git a/host/lib/usrp/usrp_c.cpp b/host/lib/usrp/usrp_c.cpp
index bda9454b6..7b8f3f8a6 100644
--- a/host/lib/usrp/usrp_c.cpp
+++ b/host/lib/usrp/usrp_c.cpp
@@ -12,8 +12,8 @@
 #include <uhd/usrp/usrp.h>
 #include <uhd/utils/static.hpp>
 #include <string.h>
-#include <boost/thread/mutex.hpp>
 #include <map>
+#include <mutex>
 
 /****************************************************************************
  * Helpers
@@ -86,17 +86,17 @@ UHD_SINGLETON_FCN(usrp_ptrs, get_usrp_ptrs);
 /****************************************************************************
  * RX Streamer
  ***************************************************************************/
-static boost::mutex _rx_streamer_make_mutex;
+static std::mutex _rx_streamer_make_mutex;
 uhd_error uhd_rx_streamer_make(uhd_rx_streamer_handle* h)
 {
-    UHD_SAFE_C(boost::mutex::scoped_lock lock(_rx_streamer_make_mutex);
+    UHD_SAFE_C(std::lock_guard<std::mutex> lock(_rx_streamer_make_mutex);
                (*h) = new uhd_rx_streamer;)
 }
 
-static boost::mutex _rx_streamer_free_mutex;
+static std::mutex _rx_streamer_free_mutex;
 uhd_error uhd_rx_streamer_free(uhd_rx_streamer_handle* h)
 {
-    UHD_SAFE_C(boost::mutex::scoped_lock lock(_rx_streamer_free_mutex); delete (*h);
+    UHD_SAFE_C(std::lock_guard<std::mutex> lock(_rx_streamer_free_mutex); delete (*h);
                (*h) = NULL;)
 }
 
@@ -142,17 +142,17 @@ uhd_error uhd_rx_streamer_last_error(
 /****************************************************************************
  * TX Streamer
  ***************************************************************************/
-static boost::mutex _tx_streamer_make_mutex;
+static std::mutex _tx_streamer_make_mutex;
 uhd_error uhd_tx_streamer_make(uhd_tx_streamer_handle* h)
 {
-    UHD_SAFE_C(boost::mutex::scoped_lock lock(_tx_streamer_make_mutex);
+    UHD_SAFE_C(std::lock_guard<std::mutex> lock(_tx_streamer_make_mutex);
                (*h) = new uhd_tx_streamer;)
 }
 
-static boost::mutex _tx_streamer_free_mutex;
+static std::mutex _tx_streamer_free_mutex;
 uhd_error uhd_tx_streamer_free(uhd_tx_streamer_handle* h)
 {
-    UHD_SAFE_C(boost::mutex::scoped_lock lock(_tx_streamer_free_mutex); delete *h;
+    UHD_SAFE_C(std::lock_guard<std::mutex> lock(_tx_streamer_free_mutex); delete *h;
                *h = NULL;)
 }
 
@@ -199,11 +199,11 @@ uhd_error uhd_tx_streamer_last_error(
 /****************************************************************************
  * Generate / Destroy API calls
  ***************************************************************************/
-static boost::mutex _usrp_find_mutex;
+static std::mutex _usrp_find_mutex;
 uhd_error uhd_usrp_find(const char* args, uhd_string_vector_handle* strings_out)
 {
     UHD_SAFE_C(
-        boost::mutex::scoped_lock _lock(_usrp_find_mutex);
+        std::lock_guard<std::mutex> _lock(_usrp_find_mutex);
 
         uhd::device_addrs_t devs =
             uhd::device::find(std::string(args), uhd::device::USRP);
@@ -212,10 +212,10 @@ uhd_error uhd_usrp_find(const char* args, uhd_string_vector_handle* strings_out)
              : devs) { (*strings_out)->string_vector_cpp.push_back(dev.to_string()); })
 }
 
-static boost::mutex _usrp_make_mutex;
+static std::mutex _usrp_make_mutex;
 uhd_error uhd_usrp_make(uhd_usrp_handle* h, const char* args)
 {
-    UHD_SAFE_C(boost::mutex::scoped_lock lock(_usrp_make_mutex);
+    UHD_SAFE_C(std::lock_guard<std::mutex> lock(_usrp_make_mutex);
 
                size_t usrp_count = usrp_ptr::usrp_counter;
                usrp_ptr::usrp_counter++;
@@ -233,11 +233,11 @@ uhd_error uhd_usrp_make(uhd_usrp_handle* h, const char* args)
                (*h)->usrp_index = usrp_count;)
 }
 
-static boost::mutex _usrp_free_mutex;
+static std::mutex _usrp_free_mutex;
 uhd_error uhd_usrp_free(uhd_usrp_handle* h)
 {
     UHD_SAFE_C(
-        boost::mutex::scoped_lock lock(_usrp_free_mutex);
+        std::lock_guard<std::mutex> lock(_usrp_free_mutex);
 
         if (!get_usrp_ptrs().count((*h)->usrp_index)) { return UHD_ERROR_INVALID_DEVICE; }
 
@@ -253,12 +253,12 @@ uhd_error uhd_usrp_last_error(uhd_usrp_handle h, char* error_out, size_t strbuff
                strncpy(error_out, h->last_error.c_str(), strbuffer_len);)
 }
 
-static boost::mutex _usrp_get_rx_stream_mutex;
+static std::mutex _usrp_get_rx_stream_mutex;
 uhd_error uhd_usrp_get_rx_stream(
     uhd_usrp_handle h_u, uhd_stream_args_t* stream_args, uhd_rx_streamer_handle h_s)
 {
     UHD_SAFE_C_SAVE_ERROR(
-        h_s, boost::mutex::scoped_lock lock(_usrp_get_rx_stream_mutex);
+        h_s, std::lock_guard<std::mutex> lock(_usrp_get_rx_stream_mutex);
 
         if (!get_usrp_ptrs().count(h_u->usrp_index)) {
             h_s->last_error = "Streamer's device is invalid or expired.";
@@ -270,12 +270,12 @@ uhd_error uhd_usrp_get_rx_stream(
         h_s->usrp_index = h_u->usrp_index;)
 }
 
-static boost::mutex _usrp_get_tx_stream_mutex;
+static std::mutex _usrp_get_tx_stream_mutex;
 uhd_error uhd_usrp_get_tx_stream(
     uhd_usrp_handle h_u, uhd_stream_args_t* stream_args, uhd_tx_streamer_handle h_s)
 {
     UHD_SAFE_C_SAVE_ERROR(
-        h_s, boost::mutex::scoped_lock lock(_usrp_get_tx_stream_mutex);
+        h_s, std::lock_guard<std::mutex> lock(_usrp_get_tx_stream_mutex);
 
         if (!get_usrp_ptrs().count(h_u->usrp_index)) {
             h_s->last_error = "Streamer's device is invalid or expired.";