diff options
Diffstat (limited to 'host')
40 files changed, 292 insertions, 297 deletions
diff --git a/host/examples/network_relay.cpp b/host/examples/network_relay.cpp index 15c6de4ef..910584452 100644 --- a/host/examples/network_relay.cpp +++ b/host/examples/network_relay.cpp @@ -8,15 +8,15 @@ #include <uhd/utils/safe_main.hpp> #include <uhd/utils/thread.hpp> #include <boost/asio.hpp> -#include <boost/format.hpp> #include <boost/program_options.hpp> -#include <boost/thread/condition_variable.hpp> +#include <boost/thread/condition.hpp> #include <boost/thread/thread.hpp> #include <chrono> #include <csignal> #include <cstdlib> #include <functional> #include <iostream> +#include <mutex> #include <thread> #include <vector> @@ -99,7 +99,7 @@ public: } std::cout << "spawning relay threads... " << _port << std::endl; - boost::unique_lock<boost::mutex> lock( + std::unique_lock<std::mutex> lock( spawn_mutex); // lock in preparation to wait for threads to spawn (void)_thread_group.create_thread( std::bind(&udp_relay_type::server_thread, this)); @@ -134,7 +134,7 @@ private: std::vector<char> buff(insane_mtu); while (not boost::this_thread::interruption_requested()) { if (wait_for_recv_ready(_server_socket->native_handle())) { - boost::mutex::scoped_lock lock(_endpoint_mutex); + std::unique_lock<std::mutex> lock(_endpoint_mutex); const size_t len = _server_socket->receive_from( asio::buffer(&buff.front(), buff.size()), _endpoint); lock.unlock(); @@ -164,7 +164,7 @@ private: if (wait_for_recv_ready(_client_socket->native_handle())) { const size_t len = _client_socket->receive(asio::buffer(&buff.front(), buff.size())); - boost::mutex::scoped_lock lock(_endpoint_mutex); + std::lock_guard<std::mutex> lock(_endpoint_mutex); _server_socket->send_to(asio::buffer(&buff.front(), len), _endpoint); } } @@ -175,10 +175,10 @@ private: boost::thread_group _thread_group; asio::io_service _io_service; asio::ip::udp::endpoint _endpoint; - boost::mutex _endpoint_mutex; + std::mutex _endpoint_mutex; socket_type _server_socket, _client_socket; - boost::mutex spawn_mutex; - boost::condition_variable wait_for_thread; + std::mutex spawn_mutex; + boost::condition wait_for_thread; }; @@ -206,7 +206,7 @@ int UHD_SAFE_MAIN(int argc, char* argv[]) // print the help message if (vm.count("help") or not vm.count("addr")) { - std::cout << boost::format("UHD Network Relay %s") % desc << std::endl + std::cout << "UHD Network Relay " << desc << std::endl << "Runs a network relay between UHD on one computer and a USRP on the " "network.\n" << "This example is basically for test purposes. Use at your own " diff --git a/host/include/uhd/transport/bounded_buffer.ipp b/host/include/uhd/transport/bounded_buffer.ipp index 3e15fc03a..122b3d740 100644 --- a/host/include/uhd/transport/bounded_buffer.ipp +++ b/host/include/uhd/transport/bounded_buffer.ipp @@ -11,9 +11,9 @@ #include <uhd/utils/noncopyable.hpp> #include <boost/circular_buffer.hpp> #include <boost/thread/condition.hpp> -#include <boost/thread/locks.hpp> #include <boost/utility.hpp> #include <functional> +#include <mutex> namespace uhd{ namespace transport{ @@ -30,9 +30,8 @@ namespace uhd{ namespace transport{ UHD_INLINE bool push_with_haste(const elem_type &elem) { - boost::mutex::scoped_lock lock(_mutex); - if (_buffer.full()) - { + std::unique_lock<std::mutex> lock(_mutex); + if (_buffer.full()) { return false; } _buffer.push_front(elem); @@ -42,15 +41,13 @@ namespace uhd{ namespace transport{ UHD_INLINE bool push_with_pop_on_full(const elem_type &elem) { - boost::mutex::scoped_lock lock(_mutex); - if (_buffer.full()) - { + std::lock_guard<std::mutex> lock(_mutex); + if (_buffer.full()) { _buffer.pop_back(); _buffer.push_front(elem); _empty_cond.notify_one(); return false; - } - else { + } else { _buffer.push_front(elem); _empty_cond.notify_one(); return true; @@ -59,7 +56,7 @@ namespace uhd{ namespace transport{ UHD_INLINE void push_with_wait(const elem_type &elem) { - boost::mutex::scoped_lock lock(_mutex); + std::unique_lock<std::mutex> lock(_mutex); if (_buffer.full()) { _full_cond.wait(lock, _not_full_fcn); @@ -70,7 +67,7 @@ namespace uhd{ namespace transport{ UHD_INLINE bool push_with_timed_wait(const elem_type &elem, double timeout) { - boost::mutex::scoped_lock lock(_mutex); + std::unique_lock<std::mutex> lock(_mutex); if (_buffer.full()) { if (not _full_cond.timed_wait(lock, @@ -86,9 +83,8 @@ namespace uhd{ namespace transport{ UHD_INLINE bool pop_with_haste(elem_type &elem) { - boost::mutex::scoped_lock lock(_mutex); - if (_buffer.empty()) - { + std::unique_lock<std::mutex> lock(_mutex); + if (_buffer.empty()) { return false; } this->pop_back(elem); @@ -98,7 +94,7 @@ namespace uhd{ namespace transport{ UHD_INLINE void pop_with_wait(elem_type &elem) { - boost::mutex::scoped_lock lock(_mutex); + std::unique_lock<std::mutex> lock(_mutex); if (_buffer.empty()) { _empty_cond.wait(lock, _not_empty_fcn); @@ -109,9 +105,8 @@ namespace uhd{ namespace transport{ UHD_INLINE bool pop_with_timed_wait(elem_type &elem, double timeout) { - boost::mutex::scoped_lock lock(_mutex); - if (_buffer.empty()) - { + std::unique_lock<std::mutex> lock(_mutex); + if (_buffer.empty()) { if (not _empty_cond.timed_wait(lock, to_time_dur(timeout), _not_empty_fcn)) { @@ -124,7 +119,7 @@ namespace uhd{ namespace transport{ } private: - boost::mutex _mutex; + std::mutex _mutex; boost::condition _empty_cond, _full_cond; boost::circular_buffer<elem_type> _buffer; diff --git a/host/include/uhd/transport/nirio/nirio_fifo.h b/host/include/uhd/transport/nirio/nirio_fifo.h index 0cd9f1906..71b9563c3 100644 --- a/host/include/uhd/transport/nirio/nirio_fifo.h +++ b/host/include/uhd/transport/nirio/nirio_fifo.h @@ -13,12 +13,12 @@ #include <uhd/transport/nirio/niriok_proxy.h> #include <uhd/transport/nirio/status.h> #include <uhd/utils/noncopyable.hpp> -#include <boost/thread/recursive_mutex.hpp> #include <atomic> -#include <string> #include <chrono> +#include <cstdint> +#include <mutex> +#include <string> #include <thread> -#include <stdint.h> namespace uhd { namespace niusrprio { @@ -213,7 +213,7 @@ private: //Members size_t _remaining_in_claimed_block; size_t _remaining_acquirable_elements; nirio_driver_iface::rio_mmap_t _mem_map; - boost::recursive_mutex _mutex; + std::recursive_mutex _mutex; niriok_proxy::sptr _riok_proxy_ptr; uint64_t _expected_xfer_count; diff --git a/host/include/uhd/transport/nirio/nirio_fifo.ipp b/host/include/uhd/transport/nirio/nirio_fifo.ipp index 048616b4c..12058aa70 100644 --- a/host/include/uhd/transport/nirio/nirio_fifo.ipp +++ b/host/include/uhd/transport/nirio/nirio_fifo.ipp @@ -61,7 +61,7 @@ nirio_status nirio_fifo<data_t>::initialize( { nirio_status status = NiRio_Status_Success; if (!_riok_proxy_ptr) return NiRio_Status_ResourceNotInitialized; - boost::unique_lock<boost::recursive_mutex> lock(_mutex); + std::unique_lock<std::recursive_mutex> lock(_mutex); if (_state == UNMAPPED) { @@ -101,7 +101,7 @@ nirio_status nirio_fifo<data_t>::initialize( template <typename data_t> void nirio_fifo<data_t>::finalize() { - boost::unique_lock<boost::recursive_mutex> lock(_mutex); + std::unique_lock<std::recursive_mutex> lock(_mutex); //If the FIFO is started, the stop will change the state to MAPPED. stop(); @@ -200,7 +200,7 @@ nirio_status nirio_fifo<data_t>::start() nirio_status status = NiRio_Status_Success; if (!_riok_proxy_ptr) return NiRio_Status_ResourceNotInitialized; - boost::unique_lock<boost::recursive_mutex> lock(_mutex); + std::unique_lock<std::recursive_mutex> lock(_mutex); if (_state == STARTED) { //Do nothing. Already started. @@ -237,7 +237,7 @@ nirio_status nirio_fifo<data_t>::stop() nirio_status status = NiRio_Status_Success; if (!_riok_proxy_ptr) return NiRio_Status_ResourceNotInitialized; - boost::unique_lock<boost::recursive_mutex> lock(_mutex); + std::unique_lock<std::recursive_mutex> lock(_mutex); if (_state == STARTED) { @@ -266,7 +266,7 @@ nirio_status nirio_fifo<data_t>::acquire( nirio_status status = NiRio_Status_Success; if (!_riok_proxy_ptr || _mem_map.is_null()) return NiRio_Status_ResourceNotInitialized; - boost::unique_lock<boost::recursive_mutex> lock(_mutex); + std::unique_lock<std::recursive_mutex> lock(_mutex); if (_state == STARTED) { @@ -320,7 +320,7 @@ nirio_status nirio_fifo<data_t>::release(const size_t elements) nirio_status status = NiRio_Status_Success; if (!_riok_proxy_ptr) return NiRio_Status_ResourceNotInitialized; - boost::unique_lock<boost::recursive_mutex> lock(_mutex); + std::unique_lock<std::recursive_mutex> lock(_mutex); if (_state == STARTED) { status = _riok_proxy_ptr->grant_fifo( @@ -345,7 +345,7 @@ nirio_status nirio_fifo<data_t>::read( nirio_status status = NiRio_Status_Success; if (!_riok_proxy_ptr) return NiRio_Status_ResourceNotInitialized; - boost::unique_lock<boost::recursive_mutex> lock(_mutex); + std::unique_lock<std::recursive_mutex> lock(_mutex); if (_state == STARTED) { status = _riok_proxy_ptr->read_fifo( @@ -375,7 +375,7 @@ nirio_status nirio_fifo<data_t>::write( nirio_status status = NiRio_Status_Success; if (!_riok_proxy_ptr) return NiRio_Status_ResourceNotInitialized; - boost::unique_lock<boost::recursive_mutex> lock(_mutex); + std::unique_lock<std::recursive_mutex> lock(_mutex); if (_state == STARTED) { status = _riok_proxy_ptr->write_fifo( diff --git a/host/include/uhd/transport/nirio/niusrprio_session.h b/host/include/uhd/transport/nirio/niusrprio_session.h index 183f766cc..432c3cd90 100644 --- a/host/include/uhd/transport/nirio/niusrprio_session.h +++ b/host/include/uhd/transport/nirio/niusrprio_session.h @@ -13,8 +13,8 @@ #include <uhd/transport/nirio/niriok_proxy.h> #include <uhd/transport/nirio/rpc/usrprio_rpc_client.hpp> #include <uhd/utils/noncopyable.hpp> -#include <stdint.h> -#include <boost/thread/recursive_mutex.hpp> +#include <cstdint> +#include <mutex> #include <string> namespace uhd { namespace niusrprio { @@ -103,7 +103,7 @@ private: niriok_proxy::sptr _riok_proxy; nirio_resource_manager _resource_manager; usrprio_rpc::usrprio_rpc_client _rpc_client; - boost::recursive_mutex _session_mutex; + std::recursive_mutex _session_mutex; }; }} // namespace uhd::niusrprio diff --git a/host/include/uhd/transport/nirio/rpc/rpc_client.hpp b/host/include/uhd/transport/nirio/rpc/rpc_client.hpp index 9361b7276..844e36c76 100644 --- a/host/include/uhd/transport/nirio/rpc/rpc_client.hpp +++ b/host/include/uhd/transport/nirio/rpc/rpc_client.hpp @@ -11,9 +11,11 @@ #include <uhd/utils/log.hpp> #include <uhd/utils/noncopyable.hpp> #include <boost/asio.hpp> -#include <boost/thread/condition_variable.hpp> -#include <boost/thread/thread.hpp> +#include <boost/date_time/posix_time/posix_time_types.hpp> +#include <boost/thread.hpp> +#include <boost/thread/condition.hpp> #include <memory> +#include <mutex> namespace uhd { namespace usrprio_rpc { @@ -76,8 +78,8 @@ private: func_xport_buf_t _request; func_xport_buf_t _response; // Synchronization - boost::mutex _mutex; - boost::condition_variable _exec_gate; + std::mutex _mutex; + boost::condition _exec_gate; boost::system::error_code _exec_err; }; diff --git a/host/include/uhd/utils/soft_register.hpp b/host/include/uhd/utils/soft_register.hpp index e38ffedfe..d23d1b8fb 100644 --- a/host/include/uhd/utils/soft_register.hpp +++ b/host/include/uhd/utils/soft_register.hpp @@ -11,12 +11,11 @@ #include <uhd/types/wb_iface.hpp> #include <uhd/utils/dirty_tracked.hpp> #include <uhd/utils/noncopyable.hpp> -#include <stdint.h> #include <unordered_map> -#include <boost/thread/locks.hpp> -#include <boost/thread/mutex.hpp> #include <boost/tokenizer.hpp> +#include <cstdint> #include <list> +#include <mutex> /*! \file soft_register.hpp * Utilities to access and index hardware registers. @@ -329,48 +328,48 @@ public: UHD_INLINE void initialize(wb_iface& iface, bool sync = false) { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); soft_register_t<reg_data_t, readable, writable>::initialize(iface, sync); } UHD_INLINE void set(const soft_reg_field_t field, const reg_data_t value) { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); soft_register_t<reg_data_t, readable, writable>::set(field, value); } UHD_INLINE reg_data_t get(const soft_reg_field_t field) { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); return soft_register_t<reg_data_t, readable, writable>::get(field); } UHD_INLINE void flush() { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); soft_register_t<reg_data_t, readable, writable>::flush(); } UHD_INLINE void refresh() { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); soft_register_t<reg_data_t, readable, writable>::refresh(); } UHD_INLINE void write(const soft_reg_field_t field, const reg_data_t value) { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); soft_register_t<reg_data_t, readable, writable>::write(field, value); } UHD_INLINE reg_data_t read(const soft_reg_field_t field) { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); return soft_register_t<reg_data_t, readable, writable>::read(field); } private: - boost::mutex _mutex; + std::mutex _mutex; }; /* @@ -483,7 +482,7 @@ public: */ void initialize(wb_iface& iface, bool sync = false) { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); for (soft_register_base* reg : _reglist) { reg->initialize(iface, sync); } @@ -496,7 +495,7 @@ public: */ void flush() { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); for (soft_register_base* reg : _reglist) { reg->flush(); } @@ -509,7 +508,7 @@ public: */ void refresh() { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); for (soft_register_base* reg : _reglist) { reg->refresh(); } @@ -555,7 +554,7 @@ protected: const std::string& name, const visibility_t visible = PRIVATE) { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); if (visible == PUBLIC) { // Only add to the map if this register is publicly visible if (not _regmap.insert(regmap_t::value_type(name, ®)).second) { @@ -573,7 +572,7 @@ private: const std::string _name; regmap_t _regmap; // For lookups reglist_t _reglist; // To maintain order - boost::mutex _mutex; + std::mutex _mutex; }; @@ -611,7 +610,7 @@ public: */ void add(soft_regmap_t& regmap) { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); _regmaps.push_back(®map); } @@ -620,7 +619,7 @@ public: */ void add(soft_regmap_db_t& db) { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); if (&db == this) { throw uhd::assertion_error("cannot add regmap db to itself" + _name); } else { @@ -700,7 +699,7 @@ private: const std::string _name; db_t _regmaps; db_t _regmap_dbs; - boost::mutex _mutex; + std::mutex _mutex; }; } // namespace uhd diff --git a/host/lib/device.cpp b/host/lib/device.cpp index 62277134b..0d64b4f4c 100644 --- a/host/lib/device.cpp +++ b/host/lib/device.cpp @@ -12,16 +12,15 @@ #include <uhd/utils/log.hpp> #include <uhd/utils/static.hpp> #include <uhdlib/utils/prefs.hpp> -#include <boost/format.hpp> #include <boost/functional/hash.hpp> -#include <boost/thread/mutex.hpp> #include <future> #include <memory> +#include <mutex> #include <tuple> using namespace uhd; -static boost::mutex _device_mutex; +static std::mutex _device_mutex; /*********************************************************************** * Helper Functions @@ -82,7 +81,7 @@ device::~device(void) **********************************************************************/ device_addrs_t device::find(const device_addr_t& hint, device_filter_t filter) { - boost::mutex::scoped_lock lock(_device_mutex); + std::lock_guard<std::mutex> lock(_device_mutex); device_addrs_t device_addrs; std::vector<std::future<device_addrs_t>> find_tasks; @@ -110,7 +109,7 @@ device_addrs_t device::find(const device_addr_t& hint, device_filter_t filter) **********************************************************************/ device::sptr device::make(const device_addr_t& hint, device_filter_t filter, size_t which) { - boost::mutex::scoped_lock lock(_device_mutex); + std::lock_guard<std::mutex> lock(_device_mutex); typedef std::tuple<device_addr_t, make_t> dev_addr_make_t; std::vector<dev_addr_make_t> dev_addr_makers; @@ -132,13 +131,13 @@ device::sptr device::make(const device_addr_t& hint, device_filter_t filter, siz // check that we found any devices if (dev_addr_makers.empty()) { throw uhd::key_error( - str(boost::format("No devices found for ----->\n%s") % hint.to_pp_string())); + std::string("No devices found for ----->\n") + hint.to_pp_string()); } // check that the which index is valid if (dev_addr_makers.size() <= which) { - throw uhd::index_error(str(boost::format("No device at index %d for ----->\n%s") - % which % hint.to_pp_string())); + throw uhd::index_error("No device at index " + std::to_string(which) + + " for ----->\n" + hint.to_pp_string()); } // create a unique hash for the device address @@ -146,7 +145,7 @@ device::sptr device::make(const device_addr_t& hint, device_filter_t filter, siz make_t maker; std::tie(dev_addr, maker) = dev_addr_makers.at(which); size_t dev_hash = hash_device_addr(dev_addr); - UHD_LOGGER_TRACE("UHD") << boost::format("Device hash: %u") % dev_hash; + UHD_LOGGER_TRACE("UHD") << "Device hash: " << dev_hash; // copy keys that were in hint but not in dev_addr // this way, we can pass additional transport arguments diff --git a/host/lib/error_c.cpp b/host/lib/error_c.cpp index 0914ca4e7..fcfa5ce06 100644 --- a/host/lib/error_c.cpp +++ b/host/lib/error_c.cpp @@ -8,8 +8,8 @@ #include <uhd/error.h> #include <uhd/exception.hpp> #include <uhd/utils/static.hpp> -#include <boost/thread/mutex.hpp> #include <cstring> +#include <mutex> #define MAP_TO_ERROR(exception_type, error_type) \ if (dynamic_cast<const uhd::exception_type*>(e)) \ @@ -40,17 +40,17 @@ uhd_error error_from_uhd_exception(const uhd::exception* e) // get_c_global_error_string() instead. UHD_SINGLETON_FCN(std::string, _c_global_error_string) -static boost::mutex _error_c_mutex; +static std::mutex _error_c_mutex; std::string get_c_global_error_string() { - boost::mutex::scoped_lock lock(_error_c_mutex); + std::lock_guard<std::mutex> lock(_error_c_mutex); return _c_global_error_string(); } void set_c_global_error_string(const std::string& msg) { - boost::mutex::scoped_lock lock(_error_c_mutex); + std::lock_guard<std::mutex> lock(_error_c_mutex); _c_global_error_string() = msg; } diff --git a/host/lib/experts/expert_container.cpp b/host/lib/experts/expert_container.cpp index 0658e9fa3..0fc159a98 100644 --- a/host/lib/experts/expert_container.cpp +++ b/host/lib/experts/expert_container.cpp @@ -14,9 +14,9 @@ #include <boost/graph/graph_traits.hpp> #include <boost/graph/topological_sort.hpp> #include <boost/thread.hpp> -#include <boost/thread/mutex.hpp> #include <functional> #include <memory> +#include <mutex> #ifdef UHD_EXPERT_LOGGING # define EX_LOG(depth, str) _log(depth, str) @@ -79,8 +79,8 @@ public: void resolve_all(bool force = false) override { - boost::lock_guard<boost::recursive_mutex> resolve_lock(_resolve_mutex); - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::recursive_mutex> resolve_lock(_resolve_mutex); + std::lock_guard<std::mutex> lock(_mutex); EX_LOG(0, str(boost::format("resolve_all(%s)") % (force ? "force" : ""))); // Do a full resolve of the graph _resolve_helper("", "", force); @@ -88,8 +88,8 @@ public: void resolve_from(const std::string&) override { - boost::lock_guard<boost::recursive_mutex> resolve_lock(_resolve_mutex); - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::recursive_mutex> resolve_lock(_resolve_mutex); + std::lock_guard<std::mutex> lock(_mutex); EX_LOG(0, "resolve_from (overridden to resolve_all)"); // Do a full resolve of the graph // Not optimizing the traversal using node_name to reduce experts complexity @@ -98,8 +98,8 @@ public: void resolve_to(const std::string&) override { - boost::lock_guard<boost::recursive_mutex> resolve_lock(_resolve_mutex); - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::recursive_mutex> resolve_lock(_resolve_mutex); + std::lock_guard<std::mutex> lock(_mutex); EX_LOG(0, "resolve_to (overridden to resolve_all)"); // Do a full resolve of the graph // Not optimizing the traversal using node_name to reduce experts complexity @@ -271,7 +271,7 @@ public: #endif } - inline boost::recursive_mutex& resolve_mutex() override + inline std::recursive_mutex& resolve_mutex() override { return _resolve_mutex; } @@ -279,7 +279,7 @@ public: protected: void add_data_node(dag_vertex_t* data_node, auto_resolve_mode_t resolve_mode) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); // Sanity check node pointer if (data_node == NULL) { @@ -330,7 +330,7 @@ protected: void add_worker(worker_node_t* worker) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); // Sanity check node pointer if (worker == NULL) { @@ -400,7 +400,7 @@ protected: void clear() override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); EX_LOG(0, "clear()"); // Iterate through the vertices and release their node storage @@ -553,8 +553,8 @@ private: vertex_map_t _worker_map; // A map from vertex name to vertex descriptor for workers vertex_map_t _datanode_map; // A map from vertex name to vertex descriptor for data nodes - boost::mutex _mutex; - boost::recursive_mutex _resolve_mutex; + std::mutex _mutex; + std::recursive_mutex _resolve_mutex; }; expert_container::sptr expert_container::make(const std::string& name) diff --git a/host/lib/include/uhdlib/experts/expert_container.hpp b/host/lib/include/uhdlib/experts/expert_container.hpp index bb05ae334..c794e9d8c 100644 --- a/host/lib/include/uhdlib/experts/expert_container.hpp +++ b/host/lib/include/uhdlib/experts/expert_container.hpp @@ -10,8 +10,8 @@ #include <uhd/config.hpp> #include <uhd/utils/noncopyable.hpp> #include <uhdlib/experts/expert_nodes.hpp> -#include <boost/thread/recursive_mutex.hpp> #include <memory> +#include <mutex> namespace uhd { namespace experts { @@ -153,7 +153,7 @@ private: * container. * */ - virtual boost::recursive_mutex& resolve_mutex() = 0; + virtual std::recursive_mutex& resolve_mutex() = 0; /*! * Add a data node to the expert graph diff --git a/host/lib/include/uhdlib/experts/expert_nodes.hpp b/host/lib/include/uhdlib/experts/expert_nodes.hpp index ce061ca26..66dd0f246 100644 --- a/host/lib/include/uhdlib/experts/expert_nodes.hpp +++ b/host/lib/include/uhdlib/experts/expert_nodes.hpp @@ -14,11 +14,12 @@ #include <uhd/utils/noncopyable.hpp> #include <stdint.h> #include <boost/core/demangle.hpp> -#include <boost/thread.hpp> -#include <boost/thread/recursive_mutex.hpp> #include <functional> #include <list> #include <memory> +#include <mutex> +#include <sstream> +#include <thread> namespace uhd { namespace experts { @@ -130,7 +131,7 @@ public: // from the outside world (of experts) using read and write callbacks. We // assume that if a callback mutex is passed into the data node that it will // be accessed from the outside and tag the data node as a PROPERTY. - data_node_t(const std::string& name, boost::recursive_mutex* mutex = NULL) + data_node_t(const std::string& name, std::recursive_mutex* mutex = NULL) : dag_vertex_t(mutex ? CLASS_PROPERTY : CLASS_DATA, name) , _callback_mutex(mutex) , _data() @@ -138,9 +139,8 @@ public: { } - data_node_t(const std::string& name, - const data_t& value, - boost::recursive_mutex* mutex = NULL) + data_node_t( + const std::string& name, const data_t& value, std::recursive_mutex* mutex = NULL) : dag_vertex_t(mutex ? CLASS_PROPERTY : CLASS_DATA, name) , _callback_mutex(mutex) , _data(value) @@ -199,7 +199,7 @@ public: if (_callback_mutex == NULL) throw uhd::assertion_error( "node " + get_name() + " is missing the callback mutex"); - boost::lock_guard<boost::recursive_mutex> lock(*_callback_mutex); + std::lock_guard<std::recursive_mutex> lock(*_callback_mutex); set(value); _author = AUTHOR_USER; if (is_dirty() and has_write_callback()) { @@ -213,7 +213,7 @@ public: if (_callback_mutex == NULL) throw uhd::assertion_error( "node " + get_name() + " is missing the callback mutex"); - boost::lock_guard<boost::recursive_mutex> lock(*_callback_mutex); + std::lock_guard<std::recursive_mutex> lock(*_callback_mutex); if (has_read_callback()) { _rd_callback(std::string(get_name())); } @@ -252,7 +252,7 @@ private: _rd_callback = nullptr; } - boost::recursive_mutex* _callback_mutex; + std::recursive_mutex* _callback_mutex; callback_func_t _rd_callback; callback_func_t _wr_callback; dirty_tracked<data_t> _data; diff --git a/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer_3000.hpp b/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer_3000.hpp index 0e1041642..7fa24f046 100644 --- a/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer_3000.hpp +++ b/host/lib/include/uhdlib/usrp/common/recv_packet_demuxer_3000.hpp @@ -13,10 +13,10 @@ #include <uhd/utils/byteswap.hpp> #include <uhd/utils/log.hpp> #include <stdint.h> -#include <boost/thread.hpp> #include <chrono> #include <map> #include <memory> +#include <mutex> #include <queue> namespace uhd { namespace usrp { @@ -62,7 +62,7 @@ struct recv_packet_demuxer_3000 : std::enable_shared_from_this<recv_packet_demux //-- Check the queue to see if we already have a buffer //---------------------------------------------------------- { - boost::mutex::scoped_lock l(mutex); + std::lock_guard<std::mutex> l(mutex); queue_type_t& queue = _queues[sid]; if (not queue.empty()) { buff = queue.front(); @@ -76,7 +76,7 @@ struct recv_packet_demuxer_3000 : std::enable_shared_from_this<recv_packet_demux if (buff) { const uint32_t new_sid = uhd::wtohx(buff->cast<const uint32_t*>()[1]); if (new_sid != sid) { - boost::mutex::scoped_lock l(mutex); + std::lock_guard<std::mutex> l(mutex); if (_queues.count(new_sid) == 0) UHD_LOGGER_ERROR("STREAMER") << "recv packet demuxer unexpected sid 0x" << std::hex @@ -92,7 +92,7 @@ struct recv_packet_demuxer_3000 : std::enable_shared_from_this<recv_packet_demux void realloc_sid(const uint32_t sid) { - boost::mutex::scoped_lock l(mutex); + std::lock_guard<std::mutex> l(mutex); while (not _queues[sid].empty()) // allocated and clears if already allocated { _queues[sid].pop(); @@ -104,7 +104,7 @@ struct recv_packet_demuxer_3000 : std::enable_shared_from_this<recv_packet_demux typedef std::queue<transport::managed_recv_buffer::sptr> queue_type_t; std::map<uint32_t, queue_type_t> _queues; transport::zero_copy_if::sptr _xport; - boost::mutex mutex; + std::mutex mutex; }; struct recv_packet_demuxer_proxy_3000 : transport::zero_copy_if diff --git a/host/lib/property_tree.cpp b/host/lib/property_tree.cpp index 53268efd3..14d3ae8c4 100644 --- a/host/lib/property_tree.cpp +++ b/host/lib/property_tree.cpp @@ -8,9 +8,8 @@ #include <uhd/property_tree.hpp> #include <uhd/types/dict.hpp> -#include <boost/thread/mutex.hpp> -#include <iostream> #include <memory> +#include <mutex> using namespace uhd; @@ -79,7 +78,7 @@ public: sptr subtree(const fs_path& path_) const override { const fs_path path = _root / path_; - boost::mutex::scoped_lock lock(_guts->mutex); + std::lock_guard<std::mutex> lock(_guts->mutex); property_tree_impl* subtree = new property_tree_impl(path); subtree->_guts = this->_guts; // copy the guts sptr @@ -89,7 +88,7 @@ public: void remove(const fs_path& path_) override { const fs_path path = _root / path_; - boost::mutex::scoped_lock lock(_guts->mutex); + std::lock_guard<std::mutex> lock(_guts->mutex); node_type* parent = NULL; node_type* node = &_guts->root; @@ -107,7 +106,7 @@ public: bool exists(const fs_path& path_) const override { const fs_path path = _root / path_; - boost::mutex::scoped_lock lock(_guts->mutex); + std::lock_guard<std::mutex> lock(_guts->mutex); node_type* node = &_guts->root; for (const std::string& name : path_tokenizer(path)) { @@ -121,7 +120,7 @@ public: std::vector<std::string> list(const fs_path& path_) const override { const fs_path path = _root / path_; - boost::mutex::scoped_lock lock(_guts->mutex); + std::lock_guard<std::mutex> lock(_guts->mutex); node_type* node = &_guts->root; for (const std::string& name : path_tokenizer(path)) { @@ -136,7 +135,7 @@ public: std::shared_ptr<void> _pop(const fs_path& path_) override { const fs_path path = _root / path_; - boost::mutex::scoped_lock lock(_guts->mutex); + std::lock_guard<std::mutex> lock(_guts->mutex); node_type* parent = NULL; node_type* node = &_guts->root; @@ -159,7 +158,7 @@ public: void _create(const fs_path& path_, const std::shared_ptr<void>& prop) override { const fs_path path = _root / path_; - boost::mutex::scoped_lock lock(_guts->mutex); + std::lock_guard<std::mutex> lock(_guts->mutex); node_type* node = &_guts->root; for (const std::string& name : path_tokenizer(path)) { @@ -176,7 +175,7 @@ public: std::shared_ptr<void>& _access(const fs_path& path_) const override { const fs_path path = _root / path_; - boost::mutex::scoped_lock lock(_guts->mutex); + std::lock_guard<std::mutex> lock(_guts->mutex); node_type* node = &_guts->root; for (const std::string& name : path_tokenizer(path)) { @@ -205,7 +204,7 @@ private: struct tree_guts_type { node_type root; - boost::mutex mutex; + std::mutex mutex; }; // members, the tree and root prefix 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 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); diff --git a/host/lib/usrp/b200/b200_radio_ctrl_core.cpp b/host/lib/usrp/b200/b200_radio_ctrl_core.cpp index e885bf1b6..7a730b1fa 100644 --- a/host/lib/usrp/b200/b200_radio_ctrl_core.cpp +++ b/host/lib/usrp/b200/b200_radio_ctrl_core.cpp @@ -14,9 +14,8 @@ #include <uhd/utils/safe_call.hpp> #include <uhdlib/usrp/common/async_packet_handler.hpp> #include <boost/format.hpp> -#include <boost/thread/mutex.hpp> -#include <boost/thread/thread.hpp> #include <functional> +#include <mutex> #include <queue> using namespace uhd; @@ -74,14 +73,14 @@ public: ******************************************************************/ void poke32(const wb_addr_type addr, const uint32_t data) override { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); this->send_pkt(addr / 4, data); this->wait_for_ack(false); } uint32_t peek32(const wb_addr_type addr) override { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); this->send_pkt(SR_READBACK, addr / 8); const uint64_t res = this->wait_for_ack(true); const uint32_t lo = uint32_t(res & 0xffffffff); @@ -91,7 +90,7 @@ public: uint64_t peek64(const wb_addr_type addr) override { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); this->send_pkt(SR_READBACK, addr / 8); return this->wait_for_ack(true); } @@ -101,7 +100,7 @@ public: ******************************************************************/ void set_time(const uhd::time_spec_t& time) override { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); _time = time; _use_time = _time != uhd::time_spec_t(0.0); if (_use_time) @@ -110,13 +109,13 @@ public: uhd::time_spec_t get_time(void) override { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); return _time; } void set_tick_rate(const double rate) override { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); _tick_rate = rate; } @@ -327,7 +326,7 @@ private: uhd::msg_task::sptr _async_task; const uint32_t _sid; const std::string _name; - boost::mutex _mutex; + std::mutex _mutex; size_t _seq_out; uhd::time_spec_t _time; bool _use_time; diff --git a/host/lib/usrp/common/recv_packet_demuxer.cpp b/host/lib/usrp/common/recv_packet_demuxer.cpp index 9d3067286..9270a40bf 100644 --- a/host/lib/usrp/common/recv_packet_demuxer.cpp +++ b/host/lib/usrp/common/recv_packet_demuxer.cpp @@ -10,8 +10,8 @@ #include <uhd/utils/byteswap.hpp> #include <uhd/utils/log.hpp> #include <uhdlib/usrp/common/recv_packet_demuxer.hpp> -#include <boost/thread/mutex.hpp> #include <deque> +#include <mutex> #include <queue> #include <vector> @@ -59,7 +59,7 @@ public: managed_recv_buffer::sptr get_recv_buff( const size_t index, const double timeout) override { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); managed_recv_buffer::sptr buff; // there is already an entry in the queue, so pop that @@ -104,7 +104,7 @@ public: private: transport::zero_copy_if::sptr _transport; const uint32_t _sid_base; - boost::mutex _mutex; + std::mutex _mutex; struct channel_guts_type { channel_guts_type(void) : wrapper(container) {} diff --git a/host/lib/usrp/cores/i2c_core_200.cpp b/host/lib/usrp/cores/i2c_core_200.cpp index 93e3fedf8..fd9332638 100644 --- a/host/lib/usrp/cores/i2c_core_200.cpp +++ b/host/lib/usrp/cores/i2c_core_200.cpp @@ -8,8 +8,8 @@ #include <uhd/exception.hpp> #include <uhd/utils/log.hpp> #include <uhdlib/usrp/cores/i2c_core_200.hpp> -#include <boost/thread/mutex.hpp> #include <chrono> +#include <mutex> #include <thread> #define REG_I2C_WR_PRESCALER_LO (1 << 3) | 0 @@ -137,13 +137,13 @@ private: void poke(const size_t what, const uint8_t cmd) { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); _iface->poke32(_base, (what << 8) | cmd); } uint8_t peek(const size_t what) { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); _iface->poke32(_base, what << 8); return uint8_t(_iface->peek32(_readback)); } @@ -151,7 +151,7 @@ private: wb_iface::sptr _iface; const size_t _base; const size_t _readback; - boost::mutex _mutex; + std::mutex _mutex; }; i2c_core_200::sptr i2c_core_200::make( diff --git a/host/lib/usrp/cores/user_settings_core_3000.cpp b/host/lib/usrp/cores/user_settings_core_3000.cpp index 9e04175c2..7293f9070 100644 --- a/host/lib/usrp/cores/user_settings_core_3000.cpp +++ b/host/lib/usrp/cores/user_settings_core_3000.cpp @@ -7,7 +7,7 @@ #include <uhd/exception.hpp> #include <uhdlib/usrp/cores/user_settings_core_3000.hpp> -#include <boost/thread/thread.hpp> +#include <mutex> using namespace uhd; @@ -38,7 +38,7 @@ public: if (offset % sizeof(uint64_t) != 0) throw uhd::value_error("peek64: Incorrect address alignment"); - boost::unique_lock<boost::mutex> lock(_mutex); + std::unique_lock<std::mutex> lock(_mutex); _iface->poke32( REG_USER_RB_ADDR, offset >> 3); // Translate byte offset to 64-bit offset return _iface->peek64(_rb_reg_addr); @@ -49,7 +49,7 @@ public: if (offset % sizeof(uint32_t) != 0) throw uhd::value_error("poke32: Incorrect address alignment"); - boost::unique_lock<boost::mutex> lock(_mutex); + std::unique_lock<std::mutex> lock(_mutex); _iface->poke32( REG_USER_SR_ADDR, offset >> 2); // Translate byte offset to 64-bit offset _iface->poke32(REG_USER_SR_DATA, value); @@ -72,7 +72,7 @@ private: wb_iface::sptr _iface; const wb_addr_type _sr_base_addr; const wb_addr_type _rb_reg_addr; - boost::mutex _mutex; + std::mutex _mutex; }; wb_iface::sptr user_settings_core_3000::make( diff --git a/host/lib/usrp/dboard/db_ubx.cpp b/host/lib/usrp/dboard/db_ubx.cpp index d36347b86..56d73bdab 100644 --- a/host/lib/usrp/dboard/db_ubx.cpp +++ b/host/lib/usrp/dboard/db_ubx.cpp @@ -21,12 +21,12 @@ #include <uhd/utils/static.hpp> #include <uhdlib/usrp/common/max287x.hpp> #include <boost/algorithm/string.hpp> -#include <boost/math/special_functions/round.hpp> -#include <boost/thread/mutex.hpp> +#include <boost/format.hpp> #include <chrono> #include <functional> #include <map> #include <memory> +#include <mutex> #include <thread> using namespace uhd; @@ -595,14 +595,14 @@ private: **********************************************************************/ void write_spi_reg(spi_dest_t dest, uint32_t value) { - boost::mutex::scoped_lock lock(_spi_mutex); + std::lock_guard<std::mutex> lock(_spi_mutex); ROUTE_SPI(_iface, dest); WRITE_SPI(_iface, value); } void write_spi_regs(spi_dest_t dest, std::vector<uint32_t> values) { - boost::mutex::scoped_lock lock(_spi_mutex); + std::lock_guard<std::mutex> lock(_spi_mutex); ROUTE_SPI(_iface, dest); for (uint32_t value : values) WRITE_SPI(_iface, value); @@ -759,7 +759,7 @@ private: **********************************************************************/ sensor_value_t get_locked(const std::string& pll_name) { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); assert_has(ubx_plls, pll_name, "ubx pll name"); if (pll_name == "TXLO") { @@ -785,7 +785,7 @@ private: // Set RX antennas std::string set_rx_ant(const std::string& ant) { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); // validate input assert_has(ubx_rx_antennas, ant, "ubx rx antenna name"); @@ -819,7 +819,7 @@ private: **********************************************************************/ double set_tx_gain(double gain) { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); gain = ubx_tx_gain_range.clip(gain); int attn_code = int(std::floor(gain * 2)); _ubx_tx_atten_val = ((attn_code & 0x3F) << 10); @@ -834,7 +834,7 @@ private: double set_rx_gain(double gain) { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); gain = ubx_rx_gain_range.clip(gain); int attn_code = int(std::floor(gain * 2)); _ubx_rx_atten_val = ((attn_code & 0x3F) << 10); @@ -852,7 +852,7 @@ private: **********************************************************************/ double set_tx_freq(double freq) { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); double freq_lo1 = 0.0; double freq_lo2 = 0.0; double ref_freq = _iface->get_clock_rate(dboard_iface::UNIT_TX); @@ -1000,7 +1000,7 @@ private: double set_rx_freq(double freq) { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); double freq_lo1 = 0.0; double freq_lo2 = 0.0; double ref_freq = _iface->get_clock_rate(dboard_iface::UNIT_RX); @@ -1186,7 +1186,7 @@ private: **********************************************************************/ void set_power_mode(std::string mode) { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); if (mode == "performance") { // performance mode attempts to reduce tuning and settling time // as much as possible without adding noise. @@ -1292,7 +1292,7 @@ private: } }(); - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); for (const auto& lo : {_txlo1, _txlo2, _rxlo1, _rxlo2}) { lo->set_auto_retune(enabled); } @@ -1302,8 +1302,8 @@ private: * Variables **********************************************************************/ dboard_iface::sptr _iface; - boost::mutex _spi_mutex; - boost::mutex _mutex; + std::mutex _spi_mutex; + std::mutex _mutex; ubx_cpld_reg_t _cpld_reg; uint32_t _prev_cpld_value; std::map<ubx_gpio_field_id_t, ubx_gpio_field_info_t> _gpio_map; diff --git a/host/lib/usrp/dboard/twinrx/twinrx_ctrl.cpp b/host/lib/usrp/dboard/twinrx/twinrx_ctrl.cpp index 29ab194be..355d980ee 100644 --- a/host/lib/usrp/dboard/twinrx/twinrx_ctrl.cpp +++ b/host/lib/usrp/dboard/twinrx/twinrx_ctrl.cpp @@ -12,6 +12,8 @@ #include <uhdlib/usrp/common/adf435x.hpp> #include <uhdlib/usrp/common/adf535x.hpp> #include <uhdlib/utils/narrow.hpp> +#include <boost/chrono.hpp> +#include <boost/format.hpp> #include <chrono> #include <cmath> #include <thread> @@ -158,19 +160,19 @@ public: ~twinrx_ctrl_impl() override { - UHD_SAFE_CALL(boost::lock_guard<boost::mutex> lock(_mutex); + UHD_SAFE_CALL(std::lock_guard<std::mutex> lock(_mutex); _gpio_iface->set_field(twinrx_gpio::FIELD_SWPS_EN, 0);) } void commit() override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); _commit(); } void set_chan_enabled(channel_t ch, bool enabled, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); if (ch == CH1 or ch == BOTH) { _cpld_regs->if0_reg3.set(rm::if0_reg3_t::IF1_IF2_EN_CH1, bool2bin(enabled)); _cpld_regs->if0_reg0.set(rm::if0_reg0_t::AMP_LO2_EN_CH1, bool2bin(enabled)); @@ -191,7 +193,7 @@ public: void set_preamp1(channel_t ch, preamp_state_t value, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); if (ch == CH1 or ch == BOTH) { _cpld_regs->rf0_reg1.set( rm::rf0_reg1_t::SWPA1_CTL_CH1, bool2bin(value == PREAMP_HIGHBAND)); @@ -218,7 +220,7 @@ public: void set_preamp2(channel_t ch, bool enabled, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); if (ch == CH1 or ch == BOTH) { _cpld_regs->rf2_reg7.set( rm::rf2_reg7_t::SWPA4_CTRL_CH1, bool2bin(not enabled)); @@ -236,7 +238,7 @@ public: void set_lb_preamp_preselector( channel_t ch, bool enabled, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); if (ch == CH1 or ch == BOTH) { _cpld_regs->rf0_reg7.set( rm::rf0_reg7_t::SWPA3_CTRL_CH1, bool2bin(not enabled)); @@ -251,7 +253,7 @@ public: void set_signal_path(channel_t ch, signal_path_t path, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); if (ch == CH1 or ch == BOTH) { _cpld_regs->rf2_reg2.set( rm::rf2_reg2_t::SW11_CTRL_CH1, bool2bin(path == PATH_LOWBAND)); @@ -299,7 +301,7 @@ public: void set_lb_preselector( channel_t ch, preselector_path_t path, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); uint32_t sw7val = 0, sw8val = 0; switch (path) { case PRESEL_PATH1: @@ -336,7 +338,7 @@ public: void set_hb_preselector( channel_t ch, preselector_path_t path, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); uint32_t sw9ch1val = 0, sw10ch1val = 0, sw9ch2val = 0, sw10ch2val = 0; switch (path) { case PRESEL_PATH1: @@ -380,7 +382,7 @@ public: void set_input_atten(channel_t ch, uint8_t atten, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); if (ch == CH1 or ch == BOTH) { _cpld_regs->rf0_reg0.set(rm::rf0_reg0_t::ATTEN_IN_CH1, atten & 0x1F); } @@ -393,7 +395,7 @@ public: void set_lb_atten(channel_t ch, uint8_t atten, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); if (ch == CH1 or ch == BOTH) { _cpld_regs->rf2_reg0.set(rm::rf2_reg0_t::ATTEN_LB_CH1, atten & 0x1F); } @@ -406,7 +408,7 @@ public: void set_hb_atten(channel_t ch, uint8_t atten, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); if (ch == CH1 or ch == BOTH) { _cpld_regs->rf1_reg0.set(rm::rf1_reg0_t::ATTEN_HB_CH1, atten & 0x1F); } @@ -419,7 +421,7 @@ public: void set_lo1_source(channel_t ch, lo_source_t source, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); if (ch == CH1 or ch == BOTH) { _cpld_regs->rf1_reg5.set( rm::rf1_reg5_t::SW14_CTRL_CH2, bool2bin(source != LO_COMPANION)); @@ -447,7 +449,7 @@ public: void set_lo2_source(channel_t ch, lo_source_t source, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); if (ch == CH1 or ch == BOTH) { _cpld_regs->if0_reg0.set( rm::if0_reg0_t::SW19_CTRL_CH2, bool2bin(source == LO_COMPANION)); @@ -472,7 +474,7 @@ public: void set_lo1_export_source(lo_export_source_t source, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); // SW22 may conflict with the cal switch but this attr takes priority and we // assume that the cal switch is disabled (by disabling it!) _set_cal_mode(CAL_DISABLED, source); @@ -486,7 +488,7 @@ public: void set_lo2_export_source(lo_export_source_t source, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); _cpld_regs->if0_reg7.set( rm::if0_reg7_t::SW24_CTRL_CH2, bool2bin(source == LO_CH2_SYNTH)); _cpld_regs->if0_reg4.set( @@ -501,7 +503,7 @@ public: void set_antenna_mapping(antenna_mapping_t mapping, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); enum switch_path_t { CONNECT, TERM, EXPORT, IMPORT, SWAP }; switch_path_t path1, path2; @@ -548,7 +550,7 @@ public: void set_crossover_cal_mode(cal_mode_t cal_mode, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); if (_lo1_export == LO_CH1_SYNTH && cal_mode == CAL_CH2) { throw uhd::runtime_error( "cannot enable cal crossover on CH2 when LO1 in CH1 is exported"); @@ -565,7 +567,7 @@ public: double set_lo1_synth_freq(channel_t ch, double freq, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); double coerced_freq = 0.0; if (ch == CH1 or ch == BOTH) { @@ -586,7 +588,7 @@ public: double set_lo2_synth_freq(channel_t ch, double freq, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); double coerced_freq = 0.0; if (ch == CH1 or ch == BOTH) { @@ -605,7 +607,7 @@ public: double set_lo1_charge_pump(channel_t ch, double current, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); double coerced_current = 0.0; if (ch == CH1 or ch == BOTH) { coerced_current = @@ -624,7 +626,7 @@ public: double set_lo2_charge_pump(channel_t ch, double current, bool commit = true) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); double coerced_current = 0.0; if (ch == CH1 or ch == BOTH) { coerced_current = @@ -655,7 +657,7 @@ public: bool read_lo1_locked(channel_t ch) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); bool locked = true; if (ch == CH1 or ch == BOTH) { @@ -671,7 +673,7 @@ public: bool read_lo2_locked(channel_t ch) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); bool locked = true; if (ch == CH1 or ch == BOTH) { @@ -851,7 +853,7 @@ private: // Members } }; - boost::mutex _mutex; + std::mutex _mutex; dboard_iface::sptr _db_iface; twinrx_gpio::sptr _gpio_iface; twinrx_cpld_regmap::sptr _cpld_regs; diff --git a/host/lib/usrp/dboard/twinrx/twinrx_io.hpp b/host/lib/usrp/dboard/twinrx/twinrx_io.hpp index 538b0bfa8..5998a87d1 100644 --- a/host/lib/usrp/dboard/twinrx/twinrx_io.hpp +++ b/host/lib/usrp/dboard/twinrx/twinrx_io.hpp @@ -12,7 +12,7 @@ #include <uhd/usrp/dboard_base.hpp> #include <uhd/utils/soft_register.hpp> #include <uhdlib/usrp/cores/gpio_atr_3000.hpp> -#include <boost/thread.hpp> +#include <boost/chrono.hpp> namespace uhd { namespace usrp { namespace dboard { namespace twinrx { @@ -95,7 +95,7 @@ public: void set_field(const uhd::soft_reg_field_t field, const uint32_t value) { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); using namespace soft_reg_field; _db_iface->set_gpio_out( @@ -104,7 +104,7 @@ public: uint32_t get_field(const uhd::soft_reg_field_t field) { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); using namespace soft_reg_field; return (_db_iface->read_gpio(dboard_iface::UNIT_BOTH) & mask<uint32_t>(field)) >> shift(field); @@ -113,7 +113,7 @@ public: // CPLD register write-only interface void poke32(const wb_addr_type addr, const uint32_t data) override { - boost::lock_guard<boost::mutex> lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); using namespace soft_reg_field; // Step 1: Write the reg offset and data to the GPIO bus and de-assert all enables @@ -140,7 +140,7 @@ private: // Members/definitions // Members dboard_iface::sptr _db_iface; - boost::mutex _mutex; + std::mutex _mutex; }; class twinrx_cpld_regmap : public uhd::soft_regmap_t diff --git a/host/lib/usrp/gps_ctrl.cpp b/host/lib/usrp/gps_ctrl.cpp index bcf938863..cafc2f662 100644 --- a/host/lib/usrp/gps_ctrl.cpp +++ b/host/lib/usrp/gps_ctrl.cpp @@ -12,12 +12,13 @@ #include <stdint.h> #include <boost/algorithm/string.hpp> #include <boost/date_time.hpp> +#include <boost/date_time/posix_time/posix_time_types.hpp> #include <boost/format.hpp> -#include <boost/thread/mutex.hpp> -#include <boost/thread/thread.hpp> +#include <boost/thread/thread_time.hpp> #include <boost/tokenizer.hpp> #include <chrono> #include <ctime> +#include <mutex> #include <regex> #include <string> #include <thread> @@ -49,7 +50,7 @@ class gps_ctrl_impl : public gps_ctrl { private: std::map<std::string, std::tuple<std::string, boost::system_time, bool>> sentences; - boost::mutex cache_mutex; + std::mutex cache_mutex; boost::system_time _last_cache_update; std::string get_sentence(const std::string which, @@ -63,7 +64,7 @@ private: boost::posix_time::time_duration age; if (wait_for_next) { - boost::lock_guard<boost::mutex> lock(cache_mutex); + std::lock_guard<std::mutex> lock(cache_mutex); update_cache(); // mark sentence as touched if (sentences.find(which) != sentences.end()) @@ -71,7 +72,7 @@ private: } while (1) { try { - boost::lock_guard<boost::mutex> lock(cache_mutex); + std::lock_guard<std::mutex> lock(cache_mutex); // update cache if older than a millisecond if (now - _last_cache_update > milliseconds(1)) { diff --git a/host/lib/usrp/usrp1/soft_time_ctrl.cpp b/host/lib/usrp/usrp1/soft_time_ctrl.cpp index 1c3015480..c23f572d0 100644 --- a/host/lib/usrp/usrp1/soft_time_ctrl.cpp +++ b/host/lib/usrp/usrp1/soft_time_ctrl.cpp @@ -8,8 +8,8 @@ #include "soft_time_ctrl.hpp" #include <uhd/utils/tasks.hpp> #include <uhdlib/utils/system_time.hpp> -#include <boost/date_time/posix_time/posix_time.hpp> -#include <boost/thread/condition_variable.hpp> +#include <boost/thread/condition.hpp> +#include <chrono> #include <functional> #include <iostream> #include <memory> @@ -52,13 +52,13 @@ public: ******************************************************************/ void set_time(const time_spec_t& time) override { - boost::mutex::scoped_lock lock(_update_mutex); + std::lock_guard<std::mutex> lock(_update_mutex); _time_offset = uhd::get_system_time() - time; } time_spec_t get_time(void) override { - boost::mutex::scoped_lock lock(_update_mutex); + std::lock_guard<std::mutex> lock(_update_mutex); return time_now(); } @@ -69,11 +69,11 @@ public: } UHD_INLINE void sleep_until_time( - boost::mutex::scoped_lock& lock, const time_spec_t& time) + std::unique_lock<std::mutex>& lock, const time_spec_t& time) { - boost::condition_variable cond; + boost::condition cond; // use a condition variable to unlock, sleep, lock - double seconds_to_sleep = (time - time_now()).get_real_secs(); + const double seconds_to_sleep = (time - time_now()).get_real_secs(); cond.timed_wait(lock, pt::microseconds(long(seconds_to_sleep * 1e6))); } @@ -82,7 +82,7 @@ public: ******************************************************************/ size_t recv_post(rx_metadata_t& md, const size_t nsamps) override { - boost::mutex::scoped_lock lock(_update_mutex); + std::lock_guard<std::mutex> lock(_update_mutex); // Since it timed out on the receive, check for inline messages... // Must do a post check because recv() will not wake up for a message. @@ -144,7 +144,7 @@ public: if (not md.has_time_spec) return; - boost::mutex::scoped_lock lock(_update_mutex); + std::unique_lock<std::mutex> lock(_update_mutex); time_spec_t time_at(md.time_spec - TWIDDLE); @@ -168,7 +168,7 @@ public: ******************************************************************/ void recv_cmd_handle_cmd(const stream_cmd_t& cmd) { - boost::mutex::scoped_lock lock(_update_mutex); + std::unique_lock<std::mutex> lock(_update_mutex); // handle the stream at time by sleeping if (not cmd.stream_now) { @@ -227,7 +227,7 @@ public: } private: - boost::mutex _update_mutex; + std::mutex _update_mutex; size_t _nsamps_remaining; stream_cmd_t::stream_mode_t _stream_mode; time_spec_t _time_offset; diff --git a/host/lib/usrp/usrp2/io_impl.cpp b/host/lib/usrp/usrp2/io_impl.cpp index 792b4721b..a966f91ea 100644 --- a/host/lib/usrp/usrp2/io_impl.cpp +++ b/host/lib/usrp/usrp2/io_impl.cpp @@ -92,7 +92,7 @@ public: */ UHD_INLINE bool check_fc_condition(double timeout) { - boost::mutex::scoped_lock lock(_fc_mutex); + std::unique_lock<std::mutex> lock(_fc_mutex); if (this->ready()) return true; boost::this_thread::disable_interruption di; // disable because the wait can throw @@ -105,7 +105,7 @@ public: */ UHD_INLINE void update_fc_condition(seq_type seq) { - boost::mutex::scoped_lock lock(_fc_mutex); + std::unique_lock<std::mutex> lock(_fc_mutex); _last_seq_ack = seq; lock.unlock(); _fc_cond.notify_one(); @@ -117,7 +117,7 @@ private: return seq_type(_last_seq_out - _last_seq_ack) < _max_seqs_out; } - boost::mutex _fc_mutex; + std::mutex _fc_mutex; boost::condition _fc_cond; seq_type _last_seq_out, _last_seq_ack; const seq_type _max_seqs_out; diff --git a/host/lib/usrp/usrp2/usrp2_fifo_ctrl.cpp b/host/lib/usrp/usrp2/usrp2_fifo_ctrl.cpp index 116051216..a4f46fca6 100644 --- a/host/lib/usrp/usrp2/usrp2_fifo_ctrl.cpp +++ b/host/lib/usrp/usrp2/usrp2_fifo_ctrl.cpp @@ -12,9 +12,7 @@ #include <uhd/utils/log.hpp> #include <uhd/utils/safe_call.hpp> #include <boost/asio.hpp> //htonl -#include <boost/format.hpp> -#include <boost/thread/mutex.hpp> -#include <boost/thread/thread.hpp> +#include <mutex> using namespace uhd; using namespace uhd::transport; @@ -58,7 +56,7 @@ public: ******************************************************************/ void poke32(const wb_addr_type addr, const uint32_t data) override { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); this->send_pkt((addr - SETTING_REGS_BASE) / 4, data, POKE32_CMD); @@ -67,7 +65,7 @@ public: uint32_t peek32(const wb_addr_type addr) override { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); this->send_pkt((addr - READBACK_BASE) / 4, 0, PEEK32_CMD); @@ -92,7 +90,7 @@ public: ******************************************************************/ void init_spi(void) { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); this->send_pkt(SPI_DIV, SPI_DIVIDER, POKE32_CMD); this->wait_for_ack(_seq_out - MAX_SEQS_OUT); @@ -106,7 +104,7 @@ public: size_t num_bits, bool readback) override { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); // load control word uint32_t ctrl_word = 0; @@ -145,7 +143,7 @@ public: ******************************************************************/ void set_time(const uhd::time_spec_t& time) override { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); _time = time; _use_time = _time != uhd::time_spec_t(0.0); if (_use_time) @@ -154,13 +152,13 @@ public: uhd::time_spec_t get_time() override { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); return _time; } void set_tick_rate(const double rate) override { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); _tick_rate = rate; } @@ -234,7 +232,7 @@ private: } zero_copy_if::sptr _xport; - boost::mutex _mutex; + std::mutex _mutex; uint16_t _seq_out; uint16_t _seq_ack; uhd::time_spec_t _time; diff --git a/host/lib/usrp/usrp2/usrp2_iface.cpp b/host/lib/usrp/usrp2/usrp2_iface.cpp index 23104d18f..c79ffccab 100644 --- a/host/lib/usrp/usrp2/usrp2_iface.cpp +++ b/host/lib/usrp/usrp2/usrp2_iface.cpp @@ -26,6 +26,7 @@ #include <chrono> #include <functional> #include <iostream> +#include <mutex> #include <thread> using namespace uhd; @@ -268,7 +269,7 @@ public: uint32_t lo = USRP2_FW_COMPAT_NUM, uint32_t hi = USRP2_FW_COMPAT_NUM) { - boost::mutex::scoped_lock lock(_ctrl_mutex); + std::lock_guard<std::mutex> lock(_ctrl_mutex); for (size_t i = 0; i < CTRL_RECV_RETRIES; i++) { try { @@ -472,7 +473,7 @@ private: udp_simple::sptr _ctrl_transport; // used in send/recv - boost::mutex _ctrl_mutex; + std::mutex _ctrl_mutex; uint32_t _ctrl_seq_num; uint32_t _protocol_compat; 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."; diff --git a/host/lib/usrp/x300/x300_fw_ctrl.cpp b/host/lib/usrp/x300/x300_fw_ctrl.cpp index 9cbad7576..110025228 100644 --- a/host/lib/usrp/x300/x300_fw_ctrl.cpp +++ b/host/lib/usrp/x300/x300_fw_ctrl.cpp @@ -16,8 +16,8 @@ #include <uhd/utils/log.hpp> #include <boost/date_time/posix_time/posix_time.hpp> #include <boost/format.hpp> -#include <boost/thread/mutex.hpp> #include <chrono> +#include <mutex> #include <thread> using namespace uhd; @@ -35,14 +35,14 @@ public: void flush(void) { - boost::mutex::scoped_lock lock(reg_access); + std::lock_guard<std::mutex> lock(reg_access); __flush(); } void poke32(const wb_addr_type addr, const uint32_t data) override { for (size_t i = 1; i <= num_retries; i++) { - boost::mutex::scoped_lock lock(reg_access); + std::lock_guard<std::mutex> lock(reg_access); try { return this->__poke32(addr, data); } catch (const uhd::io_error& ex) { @@ -60,7 +60,7 @@ public: uint32_t peek32(const wb_addr_type addr) override { for (size_t i = 1; i <= num_retries; i++) { - boost::mutex::scoped_lock lock(reg_access); + std::lock_guard<std::mutex> lock(reg_access); try { uint32_t data = this->__peek32(addr); return data; @@ -85,7 +85,7 @@ protected: virtual void __flush() = 0; virtual std::string __loc_info() = 0; - boost::mutex reg_access; + std::mutex reg_access; }; diff --git a/host/lib/usrp/x300/x300_fw_uart.cpp b/host/lib/usrp/x300/x300_fw_uart.cpp index 1bfc2a2e4..804a1a357 100644 --- a/host/lib/usrp/x300/x300_fw_uart.cpp +++ b/host/lib/usrp/x300/x300_fw_uart.cpp @@ -11,8 +11,8 @@ #include <uhd/types/serial.hpp> #include <uhd/types/wb_iface.hpp> #include <uhd/utils/log.hpp> -#include <boost/format.hpp> #include <chrono> +#include <mutex> using namespace uhd; @@ -52,7 +52,7 @@ struct x300_uart_iface : uart_iface void write_uart(const std::string& buff) override { - boost::mutex::scoped_lock lock(_write_mutex); + std::lock_guard<std::mutex> lock(_write_mutex); for (const char ch : buff) { this->putchar(ch); } @@ -120,7 +120,7 @@ struct x300_uart_iface : uart_iface std::string read_uart(double timeout) override { - boost::mutex::scoped_lock lock(_read_mutex); + std::lock_guard<std::mutex> lock(_read_mutex); const auto exit_time = std::chrono::steady_clock::now() + std::chrono::microseconds(int64_t(timeout * 1e6)); @@ -156,8 +156,8 @@ struct x300_uart_iface : uart_iface uint32_t _last_device_rxoffset; std::vector<uint32_t> _rxcache; std::string _rxbuff; - boost::mutex _read_mutex; - boost::mutex _write_mutex; + std::mutex _read_mutex; + std::mutex _write_mutex; }; uart_iface::sptr x300_make_uart_iface(wb_iface::sptr iface) 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; diff --git a/host/lib/utils/tasks.cpp b/host/lib/utils/tasks.cpp index 0eddd2488..95219cb0c 100644 --- a/host/lib/utils/tasks.cpp +++ b/host/lib/utils/tasks.cpp @@ -16,6 +16,7 @@ #include <exception> #include <functional> #include <iostream> +#include <mutex> #include <thread> #include <vector> @@ -106,7 +107,7 @@ public: */ msg_payload_t get_msg_from_dump_queue(uint32_t sid) override { - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); msg_payload_t b; for (size_t i = 0; i < _dump_queue.size(); i++) { if (sid == _dump_queue[i].first) { @@ -133,7 +134,7 @@ private: * pushed to the dump_queue. This way ctrl_cores can check dump_queue * for missing messages. */ - boost::mutex::scoped_lock lock(_mutex); + std::lock_guard<std::mutex> lock(_mutex); _dump_queue.push_back(buff.get()); } } @@ -155,7 +156,7 @@ private: << "The task loop will now exit, things may not work." << msg; } - boost::mutex _mutex; + std::mutex _mutex; boost::thread_group _thread_group; boost::barrier _spawn_barrier; bool _running; |