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.

2 files changed, 9 insertions, 9 deletions

diff --git a/host/lib/usrp_clock/octoclock/octoclock_impl.hpp b/host/lib/usrp_clock/octoclock/octoclock_impl.hpp
index 86fd5342d..f469f2dff 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_impl.hpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_impl.hpp
@@ -17,8 +17,8 @@
 #include <uhd/usrp/gps_ctrl.hpp>
 #include <uhd/usrp/mboard_eeprom.hpp>
 #include <uhd/usrp_clock/octoclock_eeprom.hpp>
-#include <boost/thread.hpp>
 #include <memory>
+#include <mutex>
 
 uhd::device_addrs_t octoclock_find(const uhd::device_addr_t& hint);
 
@@ -73,7 +73,7 @@ private:
 
     std::string _get_images_help_message(const std::string& addr);
 
-    boost::mutex _device_mutex;
+    std::mutex _device_mutex;
 };
 
 #endif /* INCLUDED_OCTOCLOCK_IMPL_HPP */
diff --git a/host/lib/usrp_clock/usrp_clock_c.cpp b/host/lib/usrp_clock/usrp_clock_c.cpp
index ea67c7e6e..c0408bc5e 100644
--- a/host/lib/usrp_clock/usrp_clock_c.cpp
+++ b/host/lib/usrp_clock/usrp_clock_c.cpp
@@ -11,8 +11,8 @@
 #include <uhd/usrp_clock/usrp_clock.h>
 #include <uhd/utils/static.hpp>
 #include <string.h>
-#include <boost/thread/mutex.hpp>
 #include <map>
+#include <mutex>
 
 /****************************************************************************
  * Registry / Pointer Management
@@ -42,11 +42,11 @@ UHD_SINGLETON_FCN(usrp_clock_ptrs, get_usrp_clock_ptrs);
 /****************************************************************************
  * Generate / Destroy API calls
  ***************************************************************************/
-static boost::mutex _usrp_clock_find_mutex;
+static std::mutex _usrp_clock_find_mutex;
 uhd_error uhd_usrp_clock_find(const char* args, uhd_string_vector_t* devices_out)
 {
     UHD_SAFE_C(
-        boost::mutex::scoped_lock lock(_usrp_clock_find_mutex);
+        std::lock_guard<std::mutex> lock(_usrp_clock_find_mutex);
 
         uhd::device_addrs_t devs =
             uhd::device::find(std::string(args), uhd::device::CLOCK);
@@ -55,10 +55,10 @@ uhd_error uhd_usrp_clock_find(const char* args, uhd_string_vector_t* devices_out
              : devs) { devices_out->string_vector_cpp.push_back(dev.to_string()); })
 }
 
-static boost::mutex _usrp_clock_make_mutex;
+static std::mutex _usrp_clock_make_mutex;
 uhd_error uhd_usrp_clock_make(uhd_usrp_clock_handle* h, const char* args)
 {
-    UHD_SAFE_C(boost::mutex::scoped_lock lock(_usrp_clock_make_mutex);
+    UHD_SAFE_C(std::lock_guard<std::mutex> lock(_usrp_clock_make_mutex);
 
                size_t usrp_clock_count = usrp_clock_ptr::usrp_clock_counter;
                usrp_clock_ptr::usrp_clock_counter++;
@@ -76,10 +76,10 @@ uhd_error uhd_usrp_clock_make(uhd_usrp_clock_handle* h, const char* args)
                (*h)->usrp_clock_index = usrp_clock_count;)
 }
 
-static boost::mutex _usrp_clock_free_mutex;
+static std::mutex _usrp_clock_free_mutex;
 uhd_error uhd_usrp_clock_free(uhd_usrp_clock_handle* h)
 {
-    UHD_SAFE_C(boost::mutex::scoped_lock lock(_usrp_clock_free_mutex);
+    UHD_SAFE_C(std::lock_guard<std::mutex> lock(_usrp_clock_free_mutex);
 
                if (!get_usrp_clock_ptrs().count((*h)->usrp_clock_index)) {
                    return UHD_ERROR_INVALID_DEVICE;