diff options
Diffstat (limited to 'host/lib/usrp')
49 files changed, 181 insertions, 181 deletions
diff --git a/host/lib/usrp/b100/b100_impl.hpp b/host/lib/usrp/b100/b100_impl.hpp index 492db5740..bb72cd63e 100644 --- a/host/lib/usrp/b100/b100_impl.hpp +++ b/host/lib/usrp/b100/b100_impl.hpp @@ -30,7 +30,7 @@ #include <uhdlib/usrp/cores/tx_dsp_core_200.hpp> #include <uhdlib/usrp/cores/time64_core_200.hpp> #include <uhdlib/usrp/cores/user_settings_core_200.hpp> -#include <boost/weak_ptr.hpp> +#include <memory> static const double B100_LINK_RATE_BPS = 256e6/5; //pratical link rate (< 480 Mbps) static const std::string B100_FW_FILE_NAME = "usrp_b100_fw.ihx"; @@ -112,14 +112,14 @@ private: //transports uhd::transport::zero_copy_if::sptr _ctrl_transport; uhd::transport::zero_copy_if::sptr _data_transport; - boost::shared_ptr<uhd::usrp::recv_packet_demuxer_3000> _recv_demuxer; + std::shared_ptr<uhd::usrp::recv_packet_demuxer_3000> _recv_demuxer; //dboard stuff uhd::usrp::dboard_manager::sptr _dboard_manager; bool _ignore_cal_file; - std::vector<boost::weak_ptr<uhd::rx_streamer> > _rx_streamers; - std::vector<boost::weak_ptr<uhd::tx_streamer> > _tx_streamers; + std::vector<std::weak_ptr<uhd::rx_streamer> > _rx_streamers; + std::vector<std::weak_ptr<uhd::tx_streamer> > _tx_streamers; void check_fw_compat(void); void check_fpga_compat(void); diff --git a/host/lib/usrp/b100/clock_ctrl.hpp b/host/lib/usrp/b100/clock_ctrl.hpp index a6f516e15..b208e8a0c 100644 --- a/host/lib/usrp/b100/clock_ctrl.hpp +++ b/host/lib/usrp/b100/clock_ctrl.hpp @@ -10,7 +10,7 @@ #include <uhd/types/serial.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <vector> /*! @@ -19,7 +19,7 @@ */ class b100_clock_ctrl : uhd::noncopyable{ public: - typedef boost::shared_ptr<b100_clock_ctrl> sptr; + typedef std::shared_ptr<b100_clock_ctrl> sptr; virtual ~b100_clock_ctrl(void) = 0; diff --git a/host/lib/usrp/b100/codec_ctrl.hpp b/host/lib/usrp/b100/codec_ctrl.hpp index 67a5f7e9c..5f77d00f9 100644 --- a/host/lib/usrp/b100/codec_ctrl.hpp +++ b/host/lib/usrp/b100/codec_ctrl.hpp @@ -11,7 +11,7 @@ #include <uhd/types/serial.hpp> #include <uhd/types/ranges.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> /*! * The B100 codec control: @@ -20,7 +20,7 @@ */ class b100_codec_ctrl : uhd::noncopyable{ public: - typedef boost::shared_ptr<b100_codec_ctrl> sptr; + typedef std::shared_ptr<b100_codec_ctrl> sptr; static const uhd::gain_range_t tx_pga_gain_range; static const uhd::gain_range_t rx_pga_gain_range; diff --git a/host/lib/usrp/b100/fifo_ctrl_excelsior.hpp b/host/lib/usrp/b100/fifo_ctrl_excelsior.hpp index 91c006a1a..27da0026c 100644 --- a/host/lib/usrp/b100/fifo_ctrl_excelsior.hpp +++ b/host/lib/usrp/b100/fifo_ctrl_excelsior.hpp @@ -12,7 +12,7 @@ #include <uhd/types/metadata.hpp> #include <uhd/types/serial.hpp> #include <uhd/transport/zero_copy.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/utility.hpp> #include <uhd/types/wb_iface.hpp> #include <string> @@ -33,7 +33,7 @@ struct fifo_ctrl_excelsior_config class fifo_ctrl_excelsior : public uhd::timed_wb_iface, public uhd::spi_iface { public: - typedef boost::shared_ptr<fifo_ctrl_excelsior> sptr; + typedef std::shared_ptr<fifo_ctrl_excelsior> sptr; //! Make a new control object static sptr make( diff --git a/host/lib/usrp/b100/io_impl.cpp b/host/lib/usrp/b100/io_impl.cpp index ed90b11ba..d3de1cca1 100644 --- a/host/lib/usrp/b100/io_impl.cpp +++ b/host/lib/usrp/b100/io_impl.cpp @@ -15,7 +15,7 @@ #include <boost/format.hpp> #include <boost/bind.hpp> #include <boost/thread.hpp> -#include <boost/make_shared.hpp> +#include <memory> using namespace uhd; using namespace uhd::usrp; @@ -38,22 +38,22 @@ void b100_impl::update_tick_rate(const double rate){ //update the tick rate on all existing streamers -> thread safe for (size_t i = 0; i < _rx_streamers.size(); i++){ - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>(_rx_streamers[i].lock()); + std::shared_ptr<sph::recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>(_rx_streamers[i].lock()); if (my_streamer.get() == NULL) continue; my_streamer->set_tick_rate(rate); } for (size_t i = 0; i < _tx_streamers.size(); i++){ - boost::shared_ptr<sph::send_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::send_packet_streamer>(_tx_streamers[i].lock()); + std::shared_ptr<sph::send_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::send_packet_streamer>(_tx_streamers[i].lock()); if (my_streamer.get() == NULL) continue; my_streamer->set_tick_rate(rate); } } void b100_impl::update_rx_samp_rate(const size_t dspno, const double rate){ - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>(_rx_streamers[dspno].lock()); + std::shared_ptr<sph::recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>(_rx_streamers[dspno].lock()); if (my_streamer.get() == NULL) return; my_streamer->set_samp_rate(rate); @@ -62,8 +62,8 @@ void b100_impl::update_rx_samp_rate(const size_t dspno, const double rate){ } void b100_impl::update_tx_samp_rate(const size_t dspno, const double rate){ - boost::shared_ptr<sph::send_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::send_packet_streamer>(_tx_streamers[dspno].lock()); + std::shared_ptr<sph::send_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::send_packet_streamer>(_tx_streamers[dspno].lock()); if (my_streamer.get() == NULL) return; my_streamer->set_samp_rate(rate); @@ -129,7 +129,7 @@ rx_streamer::sptr b100_impl::get_rx_stream(const uhd::stream_args_t &args_){ const size_t spp = unsigned(args.args.cast<double>("spp", bpp/bpi)); //make the new streamer given the samples per packet - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = boost::make_shared<sph::recv_packet_streamer>(spp); + std::shared_ptr<sph::recv_packet_streamer> my_streamer = std::make_shared<sph::recv_packet_streamer>(spp); //init some streamer stuff my_streamer->resize(args.channels.size()); @@ -188,7 +188,7 @@ tx_streamer::sptr b100_impl::get_tx_stream(const uhd::stream_args_t &args_){ const size_t spp = bpp/convert::get_bytes_per_item(args.otw_format); //make the new streamer given the samples per packet - boost::shared_ptr<sph::send_packet_streamer> my_streamer = boost::make_shared<sph::send_packet_streamer>(spp); + std::shared_ptr<sph::send_packet_streamer> my_streamer = std::make_shared<sph::send_packet_streamer>(spp); //init some streamer stuff my_streamer->resize(args.channels.size()); diff --git a/host/lib/usrp/b100/usb_zero_copy_wrapper.cpp b/host/lib/usrp/b100/usb_zero_copy_wrapper.cpp index 54c367077..6303c301d 100644 --- a/host/lib/usrp/b100/usb_zero_copy_wrapper.cpp +++ b/host/lib/usrp/b100/usb_zero_copy_wrapper.cpp @@ -11,7 +11,7 @@ #include <uhd/utils/log.hpp> #include <uhd/utils/tasks.hpp> #include <uhdlib/utils/atomic.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <boost/thread/mutex.hpp> #include <boost/thread/condition_variable.hpp> #include <boost/bind.hpp> @@ -161,9 +161,9 @@ public: _next_recv_buff_index(0) { for (size_t i = 0; i < this->get_num_recv_frames(); i++){ - _mrb_pool.push_back(boost::make_shared<usb_zero_copy_wrapper_mrb>()); + _mrb_pool.push_back(std::make_shared<usb_zero_copy_wrapper_mrb>()); } - _the_only_msb = boost::make_shared<usb_zero_copy_wrapper_msb>(usb_zc, frame_boundary); + _the_only_msb = std::make_shared<usb_zero_copy_wrapper_msb>(usb_zc, frame_boundary); } managed_recv_buffer::sptr get_recv_buff(double timeout){ @@ -211,8 +211,8 @@ public: private: zero_copy_if::sptr _internal_zc; size_t _frame_boundary; - std::vector<boost::shared_ptr<usb_zero_copy_wrapper_mrb> > _mrb_pool; - boost::shared_ptr<usb_zero_copy_wrapper_msb> _the_only_msb; + std::vector<std::shared_ptr<usb_zero_copy_wrapper_mrb> > _mrb_pool; + std::shared_ptr<usb_zero_copy_wrapper_msb> _the_only_msb; //state for last recv buffer to create multiple managed buffers managed_recv_buffer::sptr _last_recv_buff; diff --git a/host/lib/usrp/b200/b200_cores.hpp b/host/lib/usrp/b200/b200_cores.hpp index 7dabb66e9..324938a73 100644 --- a/host/lib/usrp/b200/b200_cores.hpp +++ b/host/lib/usrp/b200/b200_cores.hpp @@ -12,13 +12,13 @@ #include <uhd/utils/noncopyable.hpp> #include <uhdlib/usrp/cores/spi_core_3000.hpp> #include <uhdlib/usrp/common/adf4001_ctrl.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <mutex> class b200_local_spi_core : uhd::noncopyable, public uhd::spi_iface { public: - typedef boost::shared_ptr<b200_local_spi_core> sptr; + typedef std::shared_ptr<b200_local_spi_core> sptr; enum perif_t { CODEC, PLL @@ -47,7 +47,7 @@ private: class b200_ref_pll_ctrl : public uhd::usrp::adf4001_ctrl { public: - typedef boost::shared_ptr<b200_ref_pll_ctrl> sptr; + typedef std::shared_ptr<b200_ref_pll_ctrl> sptr; b200_ref_pll_ctrl(b200_local_spi_core::sptr spi); virtual void set_lock_to_ext_ref(bool external); diff --git a/host/lib/usrp/b200/b200_iface.hpp b/host/lib/usrp/b200/b200_iface.hpp index 4389d4eed..a3059bacf 100644 --- a/host/lib/usrp/b200/b200_iface.hpp +++ b/host/lib/usrp/b200/b200_iface.hpp @@ -13,7 +13,7 @@ #include <uhd/types/dict.hpp> #include <uhdlib/usrp/common/ad9361_ctrl.hpp> #include <boost/assign/list_of.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/utils/noncopyable.hpp> #include <stdint.h> @@ -79,7 +79,7 @@ static const uhd::dict<b200_product_t, std::string> B2XX_FPGA_FILE_NAME = boost: class UHD_API b200_iface: uhd::noncopyable, public virtual uhd::i2c_iface { public: - typedef boost::shared_ptr<b200_iface> sptr; + typedef std::shared_ptr<b200_iface> sptr; /*! * Make a b200 interface object from a control transport diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp index 1be8c263b..be21ade63 100644 --- a/host/lib/usrp/b200/b200_impl.cpp +++ b/host/lib/usrp/b200/b200_impl.cpp @@ -20,8 +20,7 @@ #include <boost/filesystem.hpp> #include <boost/lexical_cast.hpp> #include <boost/functional/hash.hpp> -#include <boost/make_shared.hpp> -#include <boost/weak_ptr.hpp> +#include <memory> #include <cstdio> #include <ctime> #include <cmath> @@ -255,7 +254,7 @@ static device::sptr b200_make(const device_addr_t &device_addr) catch (const uhd::usb_error &) { UHD_LOGGER_INFO("B200") << "Detected bad USB state; resetting." ; libusb::device_handle::sptr dev_handle(libusb::device_handle::get_cached_handle( - boost::static_pointer_cast<libusb::special_handle>(handle)->get_device() + std::static_pointer_cast<libusb::special_handle>(handle)->get_device() )); dev_handle->clear_endpoints(B200_USB_CTRL_RECV_ENDPOINT, B200_USB_CTRL_SEND_ENDPOINT); dev_handle->clear_endpoints(B200_USB_DATA_RECV_ENDPOINT, B200_USB_DATA_SEND_ENDPOINT); @@ -578,7 +577,7 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s //////////////////////////////////////////////////////////////////// _spi_iface = b200_local_spi_core::make(_local_ctrl); if (not (_product == B200MINI or _product == B205MINI)) { - _adf4001_iface = boost::make_shared<b200_ref_pll_ctrl>(_spi_iface); + _adf4001_iface = std::make_shared<b200_ref_pll_ctrl>(_spi_iface); } //////////////////////////////////////////////////////////////////// @@ -588,9 +587,9 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s reset_codec(); ad9361_params::sptr client_settings; if (_product == B200MINI or _product == B205MINI) { - client_settings = boost::make_shared<b2xxmini_ad9361_client_t>(); + client_settings = std::make_shared<b2xxmini_ad9361_client_t>(); } else { - client_settings = boost::make_shared<b200_ad9361_client_t>(); + client_settings = std::make_shared<b200_ad9361_client_t>(); } _codec_ctrl = ad9361_ctrl::make_spi(client_settings, _spi_iface, AD9361_SLAVENO); diff --git a/host/lib/usrp/b200/b200_impl.hpp b/host/lib/usrp/b200/b200_impl.hpp index 6e777d4d6..bd44aa14f 100644 --- a/host/lib/usrp/b200/b200_impl.hpp +++ b/host/lib/usrp/b200/b200_impl.hpp @@ -36,8 +36,8 @@ #include <uhdlib/usrp/common/ad936x_manager.hpp> #include <uhdlib/usrp/common/adf4001_ctrl.hpp> #include <boost/assign.hpp> -#include <boost/weak_ptr.hpp> #include <mutex> +#include <memory> static const uint8_t B200_FW_COMPAT_NUM_MAJOR = 8; static const uint8_t B200_FW_COMPAT_NUM_MINOR = 0; @@ -138,7 +138,7 @@ private: uhd::usrp::ad9361_ctrl::sptr _codec_ctrl; uhd::usrp::ad936x_manager::sptr _codec_mgr; b200_local_spi_core::sptr _spi_iface; - boost::shared_ptr<uhd::usrp::adf4001_ctrl> _adf4001_iface; + std::shared_ptr<uhd::usrp::adf4001_ctrl> _adf4001_iface; uhd::gps_ctrl::sptr _gps; //transports @@ -146,8 +146,8 @@ private: uhd::transport::zero_copy_if::sptr _ctrl_transport; uhd::usrp::recv_packet_demuxer_3000::sptr _demux; - boost::weak_ptr<uhd::rx_streamer> _rx_streamer; - boost::weak_ptr<uhd::tx_streamer> _tx_streamer; + std::weak_ptr<uhd::rx_streamer> _rx_streamer; + std::weak_ptr<uhd::tx_streamer> _tx_streamer; std::mutex _transport_setup_mutex; @@ -156,13 +156,13 @@ private: typedef uhd::transport::bounded_buffer<uhd::async_metadata_t> async_md_type; struct AsyncTaskData { - boost::shared_ptr<async_md_type> async_md; - boost::weak_ptr<radio_ctrl_core_3000> local_ctrl; - boost::weak_ptr<radio_ctrl_core_3000> radio_ctrl[2]; + std::shared_ptr<async_md_type> async_md; + std::weak_ptr<radio_ctrl_core_3000> local_ctrl; + std::weak_ptr<radio_ctrl_core_3000> radio_ctrl[2]; b200_uart::sptr gpsdo_uart; }; - boost::shared_ptr<AsyncTaskData> _async_task_data; - boost::optional<uhd::msg_task::msg_type_t> handle_async_task(uhd::transport::zero_copy_if::sptr, boost::shared_ptr<AsyncTaskData>); + std::shared_ptr<AsyncTaskData> _async_task_data; + boost::optional<uhd::msg_task::msg_type_t> handle_async_task(uhd::transport::zero_copy_if::sptr, std::shared_ptr<AsyncTaskData>); void register_loopback_self_test(uhd::wb_iface::sptr iface); void set_mb_eeprom(const uhd::usrp::mboard_eeprom_t &); @@ -191,8 +191,8 @@ private: rx_dsp_core_3000::sptr ddc; tx_vita_core_3000::sptr deframer; tx_dsp_core_3000::sptr duc; - boost::weak_ptr<uhd::rx_streamer> rx_streamer; - boost::weak_ptr<uhd::tx_streamer> tx_streamer; + std::weak_ptr<uhd::rx_streamer> rx_streamer; + std::weak_ptr<uhd::tx_streamer> tx_streamer; user_settings_core_3000::sptr user_settings; bool ant_rx2; }; diff --git a/host/lib/usrp/b200/b200_io_impl.cpp b/host/lib/usrp/b200/b200_io_impl.cpp index 5a0de430f..88cde6071 100644 --- a/host/lib/usrp/b200/b200_io_impl.cpp +++ b/host/lib/usrp/b200/b200_io_impl.cpp @@ -13,7 +13,7 @@ #include <uhdlib/usrp/common/async_packet_handler.hpp> #include <uhdlib/usrp/common/validate_subdev_spec.hpp> #include <boost/bind.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <set> using namespace uhd; @@ -37,15 +37,15 @@ size_t b200_impl::max_chan_count(const std::string& direction /* = "" */) for (radio_perifs_t& perif : _radio_perifs) { if ((direction == "RX" or direction.empty()) and not perif.rx_streamer.expired()) { - boost::shared_ptr<sph::recv_packet_streamer> rx_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>( + std::shared_ptr<sph::recv_packet_streamer> rx_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>( perif.rx_streamer.lock()); max_count = std::max(max_count, rx_streamer->get_num_channels()); } if ((direction == "TX" or direction.empty()) and not perif.tx_streamer.expired()) { - boost::shared_ptr<sph::send_packet_streamer> tx_streamer = - boost::dynamic_pointer_cast<sph::send_packet_streamer>( + std::shared_ptr<sph::send_packet_streamer> tx_streamer = + std::dynamic_pointer_cast<sph::send_packet_streamer>( perif.tx_streamer.lock()); max_count = std::max(max_count, tx_streamer->get_num_channels()); } @@ -142,16 +142,16 @@ void b200_impl::update_tick_rate(const double new_tick_rate) check_tick_rate_with_current_streamers(new_tick_rate); for (radio_perifs_t& perif : _radio_perifs) { - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>( + std::shared_ptr<sph::recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>( perif.rx_streamer.lock()); if (my_streamer) my_streamer->set_tick_rate(new_tick_rate); perif.framer->set_tick_rate(new_tick_rate); } for (radio_perifs_t& perif : _radio_perifs) { - boost::shared_ptr<sph::send_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::send_packet_streamer>( + std::shared_ptr<sph::send_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::send_packet_streamer>( perif.tx_streamer.lock()); if (my_streamer) my_streamer->set_tick_rate(new_tick_rate); @@ -204,8 +204,8 @@ double b200_impl::coerce_rx_samp_rate( void b200_impl::update_rx_samp_rate(const size_t dspno, const double rate) { - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>( + std::shared_ptr<sph::recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>( _radio_perifs[dspno].rx_streamer.lock()); if (not my_streamer) return; @@ -231,8 +231,8 @@ double b200_impl::coerce_tx_samp_rate( void b200_impl::update_tx_samp_rate(const size_t dspno, const double rate) { - boost::shared_ptr<sph::send_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::send_packet_streamer>( + std::shared_ptr<sph::send_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::send_packet_streamer>( _radio_perifs[dspno].tx_streamer.lock()); if (not my_streamer) return; @@ -314,7 +314,7 @@ bool b200_impl::recv_async_msg(async_metadata_t& async_metadata, double timeout) * there. */ boost::optional<uhd::msg_task::msg_type_t> b200_impl::handle_async_task( - uhd::transport::zero_copy_if::sptr xport, boost::shared_ptr<AsyncTaskData> data) + uhd::transport::zero_copy_if::sptr xport, std::shared_ptr<AsyncTaskData> data) { managed_recv_buffer::sptr buff = xport->get_recv_buff(); if (not buff or buff->size() < 8) @@ -405,7 +405,7 @@ rx_streamer::sptr b200_impl::get_rx_stream(const uhd::stream_args_t& args_) } check_streamer_args(args, this->get_tick_rate(), "RX"); - boost::shared_ptr<sph::recv_packet_streamer> my_streamer; + std::shared_ptr<sph::recv_packet_streamer> my_streamer; for (size_t stream_i = 0; stream_i < args.channels.size(); stream_i++) { const size_t radio_index = _tree->access<std::vector<size_t>>("/mboards/0/rx_chan_dsp_mapping") @@ -437,7 +437,7 @@ rx_streamer::sptr b200_impl::get_rx_stream(const uhd::stream_args_t& args_) // make the new streamer given the samples per packet if (not my_streamer) - my_streamer = boost::make_shared<sph::recv_packet_streamer>(spp); + my_streamer = std::make_shared<sph::recv_packet_streamer>(spp); my_streamer->resize(args.channels.size()); // init some streamer stuff @@ -480,8 +480,8 @@ rx_streamer::sptr b200_impl::get_rx_stream(const uhd::stream_args_t& args_) void b200_impl::handle_overflow(const size_t radio_index) { - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>( + std::shared_ptr<sph::recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>( _radio_perifs[radio_index].rx_streamer.lock()); if (my_streamer->get_num_channels() == 2) // MIMO time { @@ -527,7 +527,7 @@ tx_streamer::sptr b200_impl::get_tx_stream(const uhd::stream_args_t& args_) } check_streamer_args(args, this->get_tick_rate(), "TX"); - boost::shared_ptr<sph::send_packet_streamer> my_streamer; + std::shared_ptr<sph::send_packet_streamer> my_streamer; for (size_t stream_i = 0; stream_i < args.channels.size(); stream_i++) { const size_t radio_index = _tree->access<std::vector<size_t>>("/mboards/0/tx_chan_dsp_mapping") @@ -556,7 +556,7 @@ tx_streamer::sptr b200_impl::get_tx_stream(const uhd::stream_args_t& args_) // make the new streamer given the samples per packet if (not my_streamer) - my_streamer = boost::make_shared<sph::send_packet_streamer>(spp); + my_streamer = std::make_shared<sph::send_packet_streamer>(spp); my_streamer->resize(args.channels.size()); // init some streamer stuff diff --git a/host/lib/usrp/b200/b200_uart.hpp b/host/lib/usrp/b200/b200_uart.hpp index 25dc1171e..c6de5f844 100644 --- a/host/lib/usrp/b200/b200_uart.hpp +++ b/host/lib/usrp/b200/b200_uart.hpp @@ -12,12 +12,12 @@ #include <uhd/transport/zero_copy.hpp> #include <uhd/types/serial.hpp> //uart iface #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> class b200_uart: uhd::noncopyable, public uhd::uart_iface { public: - typedef boost::shared_ptr<b200_uart> sptr; + typedef std::shared_ptr<b200_uart> sptr; static sptr make(uhd::transport::zero_copy_if::sptr, const uint32_t sid); virtual void handle_uart_packet(uhd::transport::managed_recv_buffer::sptr buff) = 0; }; diff --git a/host/lib/usrp/common/ad9361_ctrl.cpp b/host/lib/usrp/common/ad9361_ctrl.cpp index b89ec2d32..8e57c48c9 100644 --- a/host/lib/usrp/common/ad9361_ctrl.cpp +++ b/host/lib/usrp/common/ad9361_ctrl.cpp @@ -10,7 +10,7 @@ #include <uhd/utils/log.hpp> #include <uhdlib/usrp/common/ad9361_ctrl.hpp> #include <boost/format.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <cstring> #include <mutex> @@ -325,8 +325,8 @@ ad9361_ctrl::sptr ad9361_ctrl::make_spi(ad9361_params::sptr client_settings, uhd::spi_iface::sptr spi_iface, uint32_t slave_num) { - boost::shared_ptr<ad9361_io_spi> spi_io_iface = - boost::make_shared<ad9361_io_spi>(spi_iface, slave_num); + std::shared_ptr<ad9361_io_spi> spi_io_iface = + std::make_shared<ad9361_io_spi>(spi_iface, slave_num); return sptr(new ad9361_ctrl_impl(client_settings, spi_io_iface)); } diff --git a/host/lib/usrp/common/ad9361_driver/ad9361_client.h b/host/lib/usrp/common/ad9361_driver/ad9361_client.h index a2343a3db..e8201825a 100644 --- a/host/lib/usrp/common/ad9361_driver/ad9361_client.h +++ b/host/lib/usrp/common/ad9361_driver/ad9361_client.h @@ -8,7 +8,7 @@ #ifndef INCLUDED_AD9361_CLIENT_H #define INCLUDED_AD9361_CLIENT_H -#include <boost/shared_ptr.hpp> +#include <memory> namespace uhd { namespace usrp { @@ -49,7 +49,7 @@ typedef struct { class ad9361_params { public: - typedef boost::shared_ptr<ad9361_params> sptr; + typedef std::shared_ptr<ad9361_params> sptr; virtual ~ad9361_params() {} @@ -62,7 +62,7 @@ public: class ad9361_io { public: - typedef boost::shared_ptr<ad9361_io> sptr; + typedef std::shared_ptr<ad9361_io> sptr; virtual ~ad9361_io() {} diff --git a/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp b/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp index a3d3552ef..44b650f52 100644 --- a/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp +++ b/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp @@ -2733,8 +2733,8 @@ filter_info_base::sptr ad9361_device_t::_get_filter_hb_2(direction_t direction) int16_t taps_array[] = {-9, 0, 73, 128, 73, 0, -9}; std::vector<int16_t> taps(taps_array, taps_array + sizeof(taps_array) / sizeof(int16_t) ); - digital_filter_base<int16_t>::sptr hb_3 = boost::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_hb_3(direction)); - digital_filter_base<int16_t>::sptr dec_int_3 = boost::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_dec_int_3(direction)); + digital_filter_base<int16_t>::sptr hb_3 = std::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_hb_3(direction)); + digital_filter_base<int16_t>::sptr dec_int_3 = std::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_dec_int_3(direction)); if(direction == RX) { @@ -2791,7 +2791,7 @@ filter_info_base::sptr ad9361_device_t::_get_filter_hb_1(direction_t direction) int16_t taps_rx_array[] = {-8, 0, 42, 0, -147, 0, 619, 1013, 619, 0, -147, 0, 42, 0, -8}; int16_t taps_tx_array[] = {-53, 0, 313, 0, -1155, 0, 4989, 8192, 4989, 0, -1155, 0, 313, 0, -53}; - digital_filter_base<int16_t>::sptr hb_2 = boost::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_hb_2(direction)); + digital_filter_base<int16_t>::sptr hb_2 = std::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_hb_2(direction)); if(direction == RX) { @@ -2826,7 +2826,7 @@ filter_info_base::sptr ad9361_device_t::_get_filter_fir(direction_t direction, c size_t max_num_taps = 128; uint8_t enable = 1; - digital_filter_base<int16_t>::sptr hb_1 = boost::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_hb_1(direction)); + digital_filter_base<int16_t>::sptr hb_1 = std::dynamic_pointer_cast<digital_filter_base<int16_t> >(_get_filter_hb_1(direction)); if(direction == RX) { @@ -2861,7 +2861,7 @@ filter_info_base::sptr ad9361_device_t::_get_filter_fir(direction_t direction, c void ad9361_device_t::_set_filter_fir(direction_t direction, chain_t channel, filter_info_base::sptr filter) { - digital_filter_fir<int16_t>::sptr fir = boost::dynamic_pointer_cast<digital_filter_fir<int16_t> >(filter); + digital_filter_fir<int16_t>::sptr fir = std::dynamic_pointer_cast<digital_filter_fir<int16_t> >(filter); //only write taps. Ignore everything else for now _set_fir_taps(direction, channel, fir->get_taps()); } @@ -2873,7 +2873,7 @@ void ad9361_device_t::_set_filter_fir(direction_t direction, chain_t channel, fi */ void ad9361_device_t::_set_filter_lp_bb(direction_t direction, filter_info_base::sptr filter) { - analog_filter_lp::sptr lpf = boost::dynamic_pointer_cast<analog_filter_lp>(filter); + analog_filter_lp::sptr lpf = std::dynamic_pointer_cast<analog_filter_lp>(filter); double bw = lpf->get_cutoff(); if(direction == RX) { @@ -2888,7 +2888,7 @@ void ad9361_device_t::_set_filter_lp_bb(direction_t direction, filter_info_base: void ad9361_device_t::_set_filter_lp_tia_sec(direction_t direction, filter_info_base::sptr filter) { - analog_filter_lp::sptr lpf = boost::dynamic_pointer_cast<analog_filter_lp>(filter); + analog_filter_lp::sptr lpf = std::dynamic_pointer_cast<analog_filter_lp>(filter); double bw = lpf->get_cutoff(); if(direction == RX) { diff --git a/host/lib/usrp/common/ad936x_manager.cpp b/host/lib/usrp/common/ad936x_manager.cpp index 5c4cb51ae..b57b94302 100644 --- a/host/lib/usrp/common/ad936x_manager.cpp +++ b/host/lib/usrp/common/ad936x_manager.cpp @@ -8,7 +8,7 @@ #include <uhd/utils/log.hpp> #include <uhdlib/usrp/common/ad936x_manager.hpp> #include <boost/functional/hash.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <chrono> #include <cmath> #include <thread> @@ -329,5 +329,5 @@ private: ad936x_manager::sptr ad936x_manager::make( const ad9361_ctrl::sptr& codec_ctrl, const size_t n_frontends) { - return boost::make_shared<ad936x_manager_impl>(codec_ctrl, n_frontends); + return std::make_shared<ad936x_manager_impl>(codec_ctrl, n_frontends); } diff --git a/host/lib/usrp/cores/spi_core_3000.cpp b/host/lib/usrp/cores/spi_core_3000.cpp index ea476879b..fb9d9d549 100644 --- a/host/lib/usrp/cores/spi_core_3000.cpp +++ b/host/lib/usrp/cores/spi_core_3000.cpp @@ -8,7 +8,7 @@ #include <uhd/exception.hpp> #include <uhdlib/usrp/cores/spi_core_3000.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <chrono> #include <mutex> #include <thread> @@ -128,7 +128,7 @@ private: spi_core_3000::sptr spi_core_3000::make( wb_iface::sptr iface, const size_t base, const size_t readback) { - return boost::make_shared<spi_core_3000_impl>( + return std::make_shared<spi_core_3000_impl>( [iface]( const uint32_t addr, const uint32_t value) { iface->poke32(addr, value); }, [iface](const uint32_t addr) { return iface->peek32(addr); }, @@ -143,6 +143,6 @@ spi_core_3000::sptr spi_core_3000::make(spi_core_3000::poke32_fn_t&& poke32_fn, const size_t reg_offset, const size_t readback) { - return boost::make_shared<spi_core_3000_impl>( + return std::make_shared<spi_core_3000_impl>( std::move(poke32_fn), std::move(peek32_fn), base, reg_offset, readback); } diff --git a/host/lib/usrp/dboard/db_sbx_common.hpp b/host/lib/usrp/dboard/db_sbx_common.hpp index 4d463603f..9c09f21a3 100644 --- a/host/lib/usrp/dboard/db_sbx_common.hpp +++ b/host/lib/usrp/dboard/db_sbx_common.hpp @@ -272,7 +272,7 @@ protected: * sbx_version* subclass, and invoke any relevant functions through that * object. This pointer is set to the proper object at construction time. */ - typedef boost::shared_ptr<sbx_versionx> sbx_versionx_sptr; + typedef std::shared_ptr<sbx_versionx> sbx_versionx_sptr; sbx_versionx_sptr db_actual; }; diff --git a/host/lib/usrp/dboard/db_twinrx.cpp b/host/lib/usrp/dboard/db_twinrx.cpp index de1cd3f33..5a8fefeb7 100644 --- a/host/lib/usrp/dboard/db_twinrx.cpp +++ b/host/lib/usrp/dboard/db_twinrx.cpp @@ -19,7 +19,7 @@ #include <uhd/utils/log.hpp> #include <uhd/utils/static.hpp> #include "dboard_ctor_args.hpp" -#include <boost/make_shared.hpp> +#include <memory> #include <boost/thread.hpp> #include <boost/thread/mutex.hpp> //#include <fstream> //Needed for _expert->to_dot() below @@ -229,13 +229,13 @@ private: class twinrx_rcvr : public rx_dboard_base { public: - typedef boost::shared_ptr<twinrx_rcvr> sptr; + typedef std::shared_ptr<twinrx_rcvr> sptr; twinrx_rcvr(ctor_args_t args) : rx_dboard_base(args) { _db_iface = get_iface(); - twinrx_gpio::sptr gpio_iface = boost::make_shared<twinrx_gpio>(_db_iface); - twinrx_cpld_regmap::sptr cpld_regs = boost::make_shared<twinrx_cpld_regmap>(); + twinrx_gpio::sptr gpio_iface = std::make_shared<twinrx_gpio>(_db_iface); + twinrx_cpld_regmap::sptr cpld_regs = std::make_shared<twinrx_cpld_regmap>(); cpld_regs->initialize(*gpio_iface, false); _ctrl = twinrx_ctrl::make(_db_iface, gpio_iface, cpld_regs, get_rx_id()); _expert = expert_factory::create_container("twinrx_expert"); @@ -304,7 +304,7 @@ public: static dboard_base::sptr make_twinrx_fe(dboard_base::ctor_args_t args) { const dboard_ctor_args_t& db_args = dboard_ctor_args_t::cast(args); - sptr container = boost::dynamic_pointer_cast<twinrx_rcvr>(db_args.rx_container); + sptr container = std::dynamic_pointer_cast<twinrx_rcvr>(db_args.rx_container); if (container) { dboard_base::sptr fe = dboard_base::sptr( new twinrx_rcvr_fe(args, container->get_expert(), container->get_ctrl())); diff --git a/host/lib/usrp/dboard/db_ubx.cpp b/host/lib/usrp/dboard/db_ubx.cpp index 305a69c52..72b3e331d 100644 --- a/host/lib/usrp/dboard/db_ubx.cpp +++ b/host/lib/usrp/dboard/db_ubx.cpp @@ -20,7 +20,7 @@ #include <uhd/utils/safe_call.hpp> #include <uhdlib/usrp/common/max287x.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/math/special_functions/round.hpp> #include <boost/algorithm/string.hpp> #include <boost/thread/mutex.hpp> @@ -1329,10 +1329,10 @@ private: 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; - boost::shared_ptr<max287x_iface> _txlo1; - boost::shared_ptr<max287x_iface> _txlo2; - boost::shared_ptr<max287x_iface> _rxlo1; - boost::shared_ptr<max287x_iface> _rxlo2; + std::shared_ptr<max287x_iface> _txlo1; + std::shared_ptr<max287x_iface> _txlo2; + std::shared_ptr<max287x_iface> _rxlo1; + std::shared_ptr<max287x_iface> _rxlo2; double _tx_target_pfd_freq; double _rx_target_pfd_freq; double _tx_gain; diff --git a/host/lib/usrp/dboard/db_wbx_common.hpp b/host/lib/usrp/dboard/db_wbx_common.hpp index ea012c91c..ec6459583 100644 --- a/host/lib/usrp/dboard/db_wbx_common.hpp +++ b/host/lib/usrp/dboard/db_wbx_common.hpp @@ -61,7 +61,7 @@ #include <uhd/usrp/dboard_base.hpp> #include <boost/assign/list_of.hpp> #include <boost/format.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/math/special_functions/round.hpp> #include <boost/bind.hpp> @@ -200,7 +200,7 @@ protected: * wbx_version_* subclass, and invoke any relevant functions through that * object. This pointer is set to the proper object at construction time. */ - typedef boost::shared_ptr<wbx_versionx> wbx_versionx_sptr; + typedef std::shared_ptr<wbx_versionx> wbx_versionx_sptr; wbx_versionx_sptr db_actual; uhd::dict<std::string, double> _tx_gains, _rx_gains; diff --git a/host/lib/usrp/dboard/magnesium/magnesium_cpld_ctrl.hpp b/host/lib/usrp/dboard/magnesium/magnesium_cpld_ctrl.hpp index 05455e3fd..8f4ee0caa 100644 --- a/host/lib/usrp/dboard/magnesium/magnesium_cpld_ctrl.hpp +++ b/host/lib/usrp/dboard/magnesium/magnesium_cpld_ctrl.hpp @@ -1,5 +1,6 @@ // // Copyright 2017 Ettus Research, a National Instruments Company +// Copyright 2019 Ettus Research, a National Instruments Brand // // SPDX-License-Identifier: GPL-3.0-or-later // @@ -12,6 +13,7 @@ #include <uhd/types/serial.hpp> #include <memory> #include <mutex> +#include <functional> //! Controls the CPLD on a Magnesium daughterboard // diff --git a/host/lib/usrp/dboard/magnesium/magnesium_radio_control.cpp b/host/lib/usrp/dboard/magnesium/magnesium_radio_control.cpp index 13186e146..32c16adc6 100644 --- a/host/lib/usrp/dboard/magnesium/magnesium_radio_control.cpp +++ b/host/lib/usrp/dboard/magnesium/magnesium_radio_control.cpp @@ -18,7 +18,7 @@ #include <uhd/rfnoc/registry.hpp> #include <boost/algorithm/string.hpp> #include <boost/format.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <cmath> #include <cstdlib> #include <sstream> diff --git a/host/lib/usrp/dboard/magnesium/magnesium_radio_control_init.cpp b/host/lib/usrp/dboard/magnesium/magnesium_radio_control_init.cpp index d8a1ccba8..a1b039079 100644 --- a/host/lib/usrp/dboard/magnesium/magnesium_radio_control_init.cpp +++ b/host/lib/usrp/dboard/magnesium/magnesium_radio_control_init.cpp @@ -14,7 +14,7 @@ #include <boost/algorithm/string.hpp> #include <boost/algorithm/string/case_conv.hpp> #include <boost/algorithm/string/split.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <string> #include <vector> diff --git a/host/lib/usrp/dboard/rhodium/rhodium_radio_control.cpp b/host/lib/usrp/dboard/rhodium/rhodium_radio_control.cpp index df2c3aadd..54c6333bc 100644 --- a/host/lib/usrp/dboard/rhodium/rhodium_radio_control.cpp +++ b/host/lib/usrp/dboard/rhodium/rhodium_radio_control.cpp @@ -18,7 +18,7 @@ #include <uhdlib/utils/narrow.hpp> #include <boost/algorithm/string.hpp> #include <boost/format.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <cmath> #include <cstdlib> #include <sstream> diff --git a/host/lib/usrp/dboard/rhodium/rhodium_radio_control.hpp b/host/lib/usrp/dboard/rhodium/rhodium_radio_control.hpp index a70db79cc..8cee33f17 100644 --- a/host/lib/usrp/dboard/rhodium/rhodium_radio_control.hpp +++ b/host/lib/usrp/dboard/rhodium/rhodium_radio_control.hpp @@ -29,7 +29,7 @@ namespace uhd { namespace rfnoc { class rhodium_radio_control_impl : public radio_control_impl { public: - typedef boost::shared_ptr<rhodium_radio_control_impl> sptr; + typedef std::shared_ptr<rhodium_radio_control_impl> sptr; //! Frequency bands for RX. Bands are a function of the analog filter banks enum class rx_band { diff --git a/host/lib/usrp/dboard/twinrx/twinrx_io.hpp b/host/lib/usrp/dboard/twinrx/twinrx_io.hpp index ea1f1150a..e3e475148 100644 --- a/host/lib/usrp/dboard/twinrx/twinrx_io.hpp +++ b/host/lib/usrp/dboard/twinrx/twinrx_io.hpp @@ -41,7 +41,7 @@ static uint32_t get_reg(wb_iface::wb_addr_type addr) { class twinrx_gpio : public wb_iface { public: - typedef boost::shared_ptr<twinrx_gpio> sptr; + typedef std::shared_ptr<twinrx_gpio> sptr; //---------------------------------------------- //Public GPIO fields @@ -123,7 +123,7 @@ private: //Members/definitions class twinrx_cpld_regmap : public uhd::soft_regmap_t { public: - typedef boost::shared_ptr<twinrx_cpld_regmap> sptr; + typedef std::shared_ptr<twinrx_cpld_regmap> sptr; //---------------------------------------------- // IF CCA: CPLD 1 diff --git a/host/lib/usrp/mpmd/mpmd_impl.cpp b/host/lib/usrp/mpmd/mpmd_impl.cpp index 69f990807..cb463b3f4 100644 --- a/host/lib/usrp/mpmd/mpmd_impl.cpp +++ b/host/lib/usrp/mpmd/mpmd_impl.cpp @@ -10,7 +10,7 @@ #include <uhd/utils/static.hpp> #include <uhd/utils/tasks.hpp> #include <boost/algorithm/string.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <boost/thread.hpp> #include <chrono> #include <future> @@ -244,7 +244,7 @@ void mpmd_impl::setup_mb(mpmd_mboard_impl* mb, const size_t mb_index) ****************************************************************************/ static device::sptr mpmd_make(const device_addr_t& device_args) { - return device::sptr(boost::make_shared<mpmd_impl>(device_args)); + return device::sptr(std::make_shared<mpmd_impl>(device_args)); } UHD_STATIC_BLOCK(register_mpmd_device) diff --git a/host/lib/usrp/multi_usrp.cpp b/host/lib/usrp/multi_usrp.cpp index 6f8b794ce..4c6372fd5 100644 --- a/host/lib/usrp/multi_usrp.cpp +++ b/host/lib/usrp/multi_usrp.cpp @@ -24,7 +24,7 @@ #include <boost/assign/list_of.hpp> #include <boost/format.hpp> #include <boost/algorithm/string.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <algorithm> #include <cmath> #include <bitset> @@ -2510,9 +2510,9 @@ multi_usrp::sptr multi_usrp::make(const device_addr_t& dev_addr) device::sptr dev = device::make(dev_addr, device::USRP); - auto rfnoc_dev = boost::dynamic_pointer_cast<rfnoc::detail::rfnoc_device>(dev); + auto rfnoc_dev = std::dynamic_pointer_cast<rfnoc::detail::rfnoc_device>(dev); if (rfnoc_dev) { return rfnoc::detail::make_rfnoc_device(rfnoc_dev, dev_addr); } - return boost::make_shared<multi_usrp_impl>(dev); + return std::make_shared<multi_usrp_impl>(dev); } diff --git a/host/lib/usrp/multi_usrp_rfnoc.cpp b/host/lib/usrp/multi_usrp_rfnoc.cpp index 757872632..d7bc49639 100644 --- a/host/lib/usrp/multi_usrp_rfnoc.cpp +++ b/host/lib/usrp/multi_usrp_rfnoc.cpp @@ -15,10 +15,10 @@ #include <uhdlib/rfnoc/rfnoc_device.hpp> #include <uhdlib/usrp/gpio_defs.hpp> #include <unordered_set> -#include <boost/make_shared.hpp> #include <boost/pointer_cast.hpp> #include <algorithm> #include <chrono> +#include <memory> #include <mutex> #include <thread> #include <vector> @@ -2211,7 +2211,7 @@ multi_usrp::sptr make_rfnoc_device( detail::rfnoc_device::sptr rfnoc_device, const uhd::device_addr_t& dev_addr) { auto graph = uhd::rfnoc::detail::make_rfnoc_graph(rfnoc_device, dev_addr); - return boost::make_shared<multi_usrp_rfnoc>(graph, dev_addr); + return std::make_shared<multi_usrp_rfnoc>(graph, dev_addr); } }}} // namespace uhd::rfnoc::detail diff --git a/host/lib/usrp/usrp1/codec_ctrl.hpp b/host/lib/usrp/usrp1/codec_ctrl.hpp index dd038fb82..c03947673 100644 --- a/host/lib/usrp/usrp1/codec_ctrl.hpp +++ b/host/lib/usrp/usrp1/codec_ctrl.hpp @@ -11,7 +11,7 @@ #include <uhd/types/serial.hpp> #include <uhd/types/ranges.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> /*! * The usrp1 codec control: @@ -20,7 +20,7 @@ */ class usrp1_codec_ctrl : uhd::noncopyable{ public: - typedef boost::shared_ptr<usrp1_codec_ctrl> sptr; + typedef std::shared_ptr<usrp1_codec_ctrl> sptr; static const uhd::gain_range_t tx_pga_gain_range; static const uhd::gain_range_t rx_pga_gain_range; diff --git a/host/lib/usrp/usrp1/io_impl.cpp b/host/lib/usrp/usrp1/io_impl.cpp index 3ccfa11c9..3d45824e4 100644 --- a/host/lib/usrp/usrp1/io_impl.cpp +++ b/host/lib/usrp/usrp1/io_impl.cpp @@ -21,7 +21,7 @@ #include <boost/thread/thread.hpp> #include <boost/bind.hpp> #include <boost/format.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <atomic> #include <chrono> #include <thread> @@ -508,8 +508,8 @@ double usrp1_impl::update_rx_samp_rate(size_t dspno, const double samp_rate){ this->restore_rx(s); //update the streamer if created - boost::shared_ptr<usrp1_recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<usrp1_recv_packet_streamer>(_rx_streamer.lock()); + std::shared_ptr<usrp1_recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<usrp1_recv_packet_streamer>(_rx_streamer.lock()); if (my_streamer.get() != NULL){ my_streamer->set_samp_rate(_master_clock_rate / rate); } @@ -530,8 +530,8 @@ double usrp1_impl::update_tx_samp_rate(size_t dspno, const double samp_rate){ this->restore_tx(s); //update the streamer if created - boost::shared_ptr<usrp1_send_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<usrp1_send_packet_streamer>(_tx_streamer.lock()); + std::shared_ptr<usrp1_send_packet_streamer> my_streamer = + std::dynamic_pointer_cast<usrp1_send_packet_streamer>(_tx_streamer.lock()); if (my_streamer.get() != NULL){ my_streamer->set_samp_rate(_master_clock_rate / rate); } @@ -631,8 +631,8 @@ rx_streamer::sptr usrp1_impl::get_rx_stream(const uhd::stream_args_t &args_){ const size_t spp = bpp/convert::get_bytes_per_item(args.otw_format); //make the new streamer given the samples per packet - boost::shared_ptr<usrp1_recv_packet_streamer> my_streamer = - boost::make_shared<usrp1_recv_packet_streamer>(spp, _soft_time_ctrl); + std::shared_ptr<usrp1_recv_packet_streamer> my_streamer = + std::make_shared<usrp1_recv_packet_streamer>(spp, _soft_time_ctrl); //init some streamer stuff my_streamer->set_tick_rate(_master_clock_rate); @@ -688,8 +688,8 @@ tx_streamer::sptr usrp1_impl::get_tx_stream(const uhd::stream_args_t &args_){ //make the new streamer given the samples per packet boost::function<void(bool)> tx_fcn = boost::bind(&usrp1_impl::tx_stream_on_off, this, _1); - boost::shared_ptr<usrp1_send_packet_streamer> my_streamer = - boost::make_shared<usrp1_send_packet_streamer>(spp, _soft_time_ctrl, tx_fcn); + std::shared_ptr<usrp1_send_packet_streamer> my_streamer = + std::make_shared<usrp1_send_packet_streamer>(spp, _soft_time_ctrl, tx_fcn); //init some streamer stuff my_streamer->set_tick_rate(_master_clock_rate); diff --git a/host/lib/usrp/usrp1/soft_time_ctrl.cpp b/host/lib/usrp/usrp1/soft_time_ctrl.cpp index 7f39caf8a..92031136d 100644 --- a/host/lib/usrp/usrp1/soft_time_ctrl.cpp +++ b/host/lib/usrp/usrp1/soft_time_ctrl.cpp @@ -8,7 +8,7 @@ #include "soft_time_ctrl.hpp" #include <uhdlib/utils/system_time.hpp> #include <uhd/utils/tasks.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <boost/thread/condition_variable.hpp> #include <boost/date_time/posix_time/posix_time.hpp> #include <iostream> @@ -116,7 +116,7 @@ public: } void issue_stream_cmd(const stream_cmd_t &cmd){ - _cmd_queue.push_with_wait(boost::make_shared<stream_cmd_t>(cmd)); + _cmd_queue.push_with_wait(std::make_shared<stream_cmd_t>(cmd)); } void stream_on_off(bool enb){ @@ -190,7 +190,7 @@ public: } void recv_cmd_task(void){ //task is looped - boost::shared_ptr<stream_cmd_t> cmd; + std::shared_ptr<stream_cmd_t> cmd; if (_cmd_queue.pop_with_timed_wait(cmd, 0.25)) { recv_cmd_handle_cmd(*cmd); } @@ -213,7 +213,7 @@ private: size_t _nsamps_remaining; stream_cmd_t::stream_mode_t _stream_mode; time_spec_t _time_offset; - bounded_buffer<boost::shared_ptr<stream_cmd_t> > _cmd_queue; + bounded_buffer<std::shared_ptr<stream_cmd_t> > _cmd_queue; bounded_buffer<async_metadata_t> _async_msg_queue; bounded_buffer<rx_metadata_t> _inline_msg_queue; const cb_fcn_type _stream_on_off; diff --git a/host/lib/usrp/usrp1/soft_time_ctrl.hpp b/host/lib/usrp/usrp1/soft_time_ctrl.hpp index 1422a5ced..9143b6af2 100644 --- a/host/lib/usrp/usrp1/soft_time_ctrl.hpp +++ b/host/lib/usrp/usrp1/soft_time_ctrl.hpp @@ -13,7 +13,7 @@ #include <uhd/types/metadata.hpp> #include <uhd/transport/bounded_buffer.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/function.hpp> namespace uhd{ namespace usrp{ @@ -27,7 +27,7 @@ namespace uhd{ namespace usrp{ */ class soft_time_ctrl : uhd::noncopyable{ public: - typedef boost::shared_ptr<soft_time_ctrl> sptr; + typedef std::shared_ptr<soft_time_ctrl> sptr; typedef boost::function<void(bool)> cb_fcn_type; virtual ~soft_time_ctrl(void) = 0; diff --git a/host/lib/usrp/usrp1/usrp1_iface.hpp b/host/lib/usrp/usrp1/usrp1_iface.hpp index 4fb5cd4ee..b01b2d088 100644 --- a/host/lib/usrp/usrp1/usrp1_iface.hpp +++ b/host/lib/usrp/usrp1/usrp1_iface.hpp @@ -11,7 +11,7 @@ #include <uhdlib/usrp/common/fx2_ctrl.hpp> #include <uhd/types/wb_iface.hpp> #include <uhd/types/serial.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/utils/noncopyable.hpp> #define SPI_ENABLE_FPGA 0x01 @@ -35,7 +35,7 @@ class usrp1_iface : public uhd::wb_iface, public uhd::i2c_iface, public uhd::spi_iface, uhd::noncopyable { public: - typedef boost::shared_ptr<usrp1_iface> sptr; + typedef std::shared_ptr<usrp1_iface> sptr; /*! * Make a new usrp1 interface with the control transport. diff --git a/host/lib/usrp/usrp1/usrp1_impl.hpp b/host/lib/usrp/usrp1/usrp1_impl.hpp index 1cf8362e1..9e0a97f47 100644 --- a/host/lib/usrp/usrp1/usrp1_impl.hpp +++ b/host/lib/usrp/usrp1/usrp1_impl.hpp @@ -5,23 +5,23 @@ // SPDX-License-Identifier: GPL-3.0-or-later // -#include "usrp1_iface.hpp" #include "codec_ctrl.hpp" #include "soft_time_ctrl.hpp" +#include "usrp1_iface.hpp" #include <uhd/device.hpp> #include <uhd/property_tree.hpp> -#include <uhd/utils/pimpl.hpp> +#include <uhd/transport/usb_zero_copy.hpp> #include <uhd/types/dict.hpp> #include <uhd/types/stream_cmd.hpp> +#include <uhd/usrp/dboard_eeprom.hpp> #include <uhd/usrp/dboard_id.hpp> +#include <uhd/usrp/dboard_manager.hpp> #include <uhd/usrp/mboard_eeprom.hpp> #include <uhd/usrp/subdev_spec.hpp> -#include <uhd/usrp/dboard_eeprom.hpp> -#include <uhd/usrp/dboard_manager.hpp> -#include <uhd/transport/usb_zero_copy.hpp> -#include <boost/weak_ptr.hpp> -#include <complex> +#include <uhd/utils/pimpl.hpp> #include <atomic> +#include <complex> +#include <memory> #ifndef INCLUDED_USRP1_IMPL_HPP #define INCLUDED_USRP1_IMPL_HPP @@ -89,8 +89,8 @@ private: double _master_clock_rate; //clock rate shadow //weak pointers to streamers for update purposes - boost::weak_ptr<uhd::rx_streamer> _rx_streamer; - boost::weak_ptr<uhd::tx_streamer> _tx_streamer; + std::weak_ptr<uhd::rx_streamer> _rx_streamer; + std::weak_ptr<uhd::tx_streamer> _tx_streamer; void set_mb_eeprom(const uhd::usrp::mboard_eeprom_t &); void set_db_eeprom(const std::string &, const std::string &, const uhd::usrp::dboard_eeprom_t &); diff --git a/host/lib/usrp/usrp2/clock_ctrl.hpp b/host/lib/usrp/usrp2/clock_ctrl.hpp index 53f0d0aef..b82dd4723 100644 --- a/host/lib/usrp/usrp2/clock_ctrl.hpp +++ b/host/lib/usrp/usrp2/clock_ctrl.hpp @@ -10,12 +10,12 @@ #include "usrp2_iface.hpp" #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <vector> class usrp2_clock_ctrl : uhd::noncopyable{ public: - typedef boost::shared_ptr<usrp2_clock_ctrl> sptr; + typedef std::shared_ptr<usrp2_clock_ctrl> sptr; virtual ~usrp2_clock_ctrl(void) = 0; diff --git a/host/lib/usrp/usrp2/codec_ctrl.hpp b/host/lib/usrp/usrp2/codec_ctrl.hpp index 37c8d6fa3..c769d102a 100644 --- a/host/lib/usrp/usrp2/codec_ctrl.hpp +++ b/host/lib/usrp/usrp2/codec_ctrl.hpp @@ -9,12 +9,12 @@ #define INCLUDED_CODEC_CTRL_HPP #include "usrp2_iface.hpp" -#include <boost/shared_ptr.hpp> +#include <memory> #include <uhd/utils/noncopyable.hpp> class usrp2_codec_ctrl : uhd::noncopyable{ public: - typedef boost::shared_ptr<usrp2_codec_ctrl> sptr; + typedef std::shared_ptr<usrp2_codec_ctrl> sptr; virtual ~usrp2_codec_ctrl(void) = 0; diff --git a/host/lib/usrp/usrp2/io_impl.cpp b/host/lib/usrp/usrp2/io_impl.cpp index 7042f0391..d965b4e24 100644 --- a/host/lib/usrp/usrp2/io_impl.cpp +++ b/host/lib/usrp/usrp2/io_impl.cpp @@ -24,7 +24,7 @@ #include <boost/bind.hpp> #include <boost/asio.hpp> #include <boost/thread/mutex.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <iostream> #include <chrono> #include <thread> @@ -55,7 +55,7 @@ static const size_t vrt_send_header_offset_words32 = 1; class flow_control_monitor{ public: typedef uint32_t seq_type; - typedef boost::shared_ptr<flow_control_monitor> sptr; + typedef std::shared_ptr<flow_control_monitor> sptr; /*! * Make a new flow control monitor. @@ -256,14 +256,14 @@ void usrp2_impl::update_tick_rate(const double rate){ //update the tick rate on all existing streamers -> thread safe for(const std::string &mb: _mbc.keys()){ for (size_t i = 0; i < _mbc[mb].rx_streamers.size(); i++){ - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>(_mbc[mb].rx_streamers[i].lock()); + std::shared_ptr<sph::recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>(_mbc[mb].rx_streamers[i].lock()); if (my_streamer.get() == NULL) continue; my_streamer->set_tick_rate(rate); } for (size_t i = 0; i < _mbc[mb].tx_streamers.size(); i++){ - boost::shared_ptr<sph::send_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::send_packet_streamer>(_mbc[mb].tx_streamers[i].lock()); + std::shared_ptr<sph::send_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::send_packet_streamer>(_mbc[mb].tx_streamers[i].lock()); if (my_streamer.get() == NULL) continue; my_streamer->set_tick_rate(rate); } @@ -271,8 +271,8 @@ void usrp2_impl::update_tick_rate(const double rate){ } void usrp2_impl::update_rx_samp_rate(const std::string &mb, const size_t dsp, const double rate){ - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::recv_packet_streamer>(_mbc[mb].rx_streamers[dsp].lock()); + std::shared_ptr<sph::recv_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::recv_packet_streamer>(_mbc[mb].rx_streamers[dsp].lock()); if (my_streamer.get() == NULL) return; my_streamer->set_samp_rate(rate); @@ -281,8 +281,8 @@ void usrp2_impl::update_rx_samp_rate(const std::string &mb, const size_t dsp, co } void usrp2_impl::update_tx_samp_rate(const std::string &mb, const size_t dsp, const double rate){ - boost::shared_ptr<sph::send_packet_streamer> my_streamer = - boost::dynamic_pointer_cast<sph::send_packet_streamer>(_mbc[mb].tx_streamers[dsp].lock()); + std::shared_ptr<sph::send_packet_streamer> my_streamer = + std::dynamic_pointer_cast<sph::send_packet_streamer>(_mbc[mb].tx_streamers[dsp].lock()); if (my_streamer.get() == NULL) return; my_streamer->set_samp_rate(rate); @@ -429,7 +429,7 @@ rx_streamer::sptr usrp2_impl::get_rx_stream(const uhd::stream_args_t &args_){ const size_t spp = args.args.cast<size_t>("spp", bpp/bpi); //make the new streamer given the samples per packet - boost::shared_ptr<sph::recv_packet_streamer> my_streamer = boost::make_shared<sph::recv_packet_streamer>(spp); + std::shared_ptr<sph::recv_packet_streamer> my_streamer = std::make_shared<sph::recv_packet_streamer>(spp); //init some streamer stuff my_streamer->resize(args.channels.size()); @@ -498,7 +498,7 @@ tx_streamer::sptr usrp2_impl::get_tx_stream(const uhd::stream_args_t &args_){ const size_t spp = bpp/convert::get_bytes_per_item(args.otw_format); //make the new streamer given the samples per packet - boost::shared_ptr<sph::send_packet_streamer> my_streamer = boost::make_shared<sph::send_packet_streamer>(spp); + std::shared_ptr<sph::send_packet_streamer> my_streamer = std::make_shared<sph::send_packet_streamer>(spp); //init some streamer stuff my_streamer->resize(args.channels.size()); diff --git a/host/lib/usrp/usrp2/usrp2_fifo_ctrl.hpp b/host/lib/usrp/usrp2/usrp2_fifo_ctrl.hpp index 1e670a7f4..cbb243a79 100644 --- a/host/lib/usrp/usrp2/usrp2_fifo_ctrl.hpp +++ b/host/lib/usrp/usrp2/usrp2_fifo_ctrl.hpp @@ -11,7 +11,7 @@ #include <uhd/types/time_spec.hpp> #include <uhd/types/serial.hpp> #include <uhd/transport/zero_copy.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/utility.hpp> #include <uhd/types/wb_iface.hpp> #include <string> @@ -23,7 +23,7 @@ class usrp2_fifo_ctrl : public uhd::timed_wb_iface, public uhd::spi_iface { public: - typedef boost::shared_ptr<usrp2_fifo_ctrl> sptr; + typedef std::shared_ptr<usrp2_fifo_ctrl> sptr; //! Make a new FIFO control object static sptr make(uhd::transport::zero_copy_if::sptr xport); diff --git a/host/lib/usrp/usrp2/usrp2_iface.hpp b/host/lib/usrp/usrp2/usrp2_iface.hpp index 05cdfba54..2752d1a28 100644 --- a/host/lib/usrp/usrp2/usrp2_iface.hpp +++ b/host/lib/usrp/usrp2/usrp2_iface.hpp @@ -11,7 +11,7 @@ #include <uhd/transport/udp_simple.hpp> #include <uhd/types/serial.hpp> #include <uhd/usrp/mboard_eeprom.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/utility.hpp> #include <boost/function.hpp> #include "usrp2_regs.hpp" @@ -26,7 +26,7 @@ class usrp2_iface : public uhd::timed_wb_iface, public uhd::spi_iface, public uhd::i2c_iface { public: - typedef boost::shared_ptr<usrp2_iface> sptr; + typedef std::shared_ptr<usrp2_iface> sptr; /*! * Make a new usrp2 interface with the control transport. * \param ctrl_transport the udp transport object diff --git a/host/lib/usrp/usrp2/usrp2_impl.hpp b/host/lib/usrp/usrp2/usrp2_impl.hpp index 4c86ca7c8..14a3ae8d6 100644 --- a/host/lib/usrp/usrp2/usrp2_impl.hpp +++ b/host/lib/usrp/usrp2/usrp2_impl.hpp @@ -32,8 +32,7 @@ #include <uhd/types/device_addr.hpp> #include <uhd/usrp/dboard_manager.hpp> #include <uhd/usrp/subdev_spec.hpp> -#include <boost/weak_ptr.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/function.hpp> #include <atomic> @@ -84,8 +83,8 @@ private: rx_frontend_core_200::sptr rx_fe; tx_frontend_core_200::sptr tx_fe; std::vector<rx_dsp_core_200::sptr> rx_dsps; - std::vector<boost::weak_ptr<uhd::rx_streamer> > rx_streamers; - std::vector<boost::weak_ptr<uhd::tx_streamer> > tx_streamers; + std::vector<std::weak_ptr<uhd::rx_streamer> > rx_streamers; + std::vector<std::weak_ptr<uhd::tx_streamer> > tx_streamers; tx_dsp_core_200::sptr tx_dsp; time64_core_200::sptr time64; user_settings_core_200::sptr user; diff --git a/host/lib/usrp/x300/x300_adc_ctrl.hpp b/host/lib/usrp/x300/x300_adc_ctrl.hpp index 354b8db49..c69c4c427 100644 --- a/host/lib/usrp/x300/x300_adc_ctrl.hpp +++ b/host/lib/usrp/x300/x300_adc_ctrl.hpp @@ -10,12 +10,12 @@ #include <uhd/types/serial.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> class x300_adc_ctrl : uhd::noncopyable { public: - typedef boost::shared_ptr<x300_adc_ctrl> sptr; + typedef std::shared_ptr<x300_adc_ctrl> sptr; virtual ~x300_adc_ctrl(void) = 0; diff --git a/host/lib/usrp/x300/x300_clock_ctrl.hpp b/host/lib/usrp/x300/x300_clock_ctrl.hpp index 25c2dd33f..af8c3c162 100644 --- a/host/lib/usrp/x300/x300_clock_ctrl.hpp +++ b/host/lib/usrp/x300/x300_clock_ctrl.hpp @@ -10,7 +10,7 @@ #include <uhd/types/serial.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> enum x300_clock_which_t { @@ -28,7 +28,7 @@ enum x300_clock_which_t { class x300_clock_ctrl : uhd::noncopyable { public: - typedef boost::shared_ptr<x300_clock_ctrl> sptr; + typedef std::shared_ptr<x300_clock_ctrl> sptr; virtual ~x300_clock_ctrl(void) = 0; diff --git a/host/lib/usrp/x300/x300_dac_ctrl.hpp b/host/lib/usrp/x300/x300_dac_ctrl.hpp index d73a03d63..9844ffce6 100644 --- a/host/lib/usrp/x300/x300_dac_ctrl.hpp +++ b/host/lib/usrp/x300/x300_dac_ctrl.hpp @@ -10,12 +10,12 @@ #include <uhd/types/serial.hpp> #include <uhd/utils/noncopyable.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> class x300_dac_ctrl : uhd::noncopyable { public: - typedef boost::shared_ptr<x300_dac_ctrl> sptr; + typedef std::shared_ptr<x300_dac_ctrl> sptr; virtual ~x300_dac_ctrl(void) = 0; diff --git a/host/lib/usrp/x300/x300_mb_eeprom_iface.cpp b/host/lib/usrp/x300/x300_mb_eeprom_iface.cpp index b4dab8291..42d0b32ca 100644 --- a/host/lib/usrp/x300/x300_mb_eeprom_iface.cpp +++ b/host/lib/usrp/x300/x300_mb_eeprom_iface.cpp @@ -27,7 +27,7 @@ #include <uhd/utils/log.hpp> #include <uhd/utils/platform.hpp> #include <boost/thread.hpp> -#include <boost/make_shared.hpp> +#include <memory> using namespace uhd; @@ -158,5 +158,5 @@ x300_mb_eeprom_iface::~x300_mb_eeprom_iface(void) x300_mb_eeprom_iface::sptr x300_mb_eeprom_iface::make( wb_iface::sptr wb, i2c_iface::sptr i2c) { - return boost::make_shared<x300_mb_eeprom_iface_impl>(wb, i2c->eeprom16()); + return std::make_shared<x300_mb_eeprom_iface_impl>(wb, i2c->eeprom16()); } diff --git a/host/lib/usrp/x300/x300_mb_eeprom_iface.hpp b/host/lib/usrp/x300/x300_mb_eeprom_iface.hpp index d323d6359..2d08d5711 100644 --- a/host/lib/usrp/x300/x300_mb_eeprom_iface.hpp +++ b/host/lib/usrp/x300/x300_mb_eeprom_iface.hpp @@ -11,13 +11,13 @@ #include <uhd/config.hpp> #include <uhd/types/serial.hpp> #include <uhd/types/wb_iface.hpp> -#include <boost/shared_ptr.hpp> +#include <memory> #include <boost/utility.hpp> class x300_mb_eeprom_iface : public uhd::i2c_iface { public: - typedef boost::shared_ptr<x300_mb_eeprom_iface> sptr; + typedef std::shared_ptr<x300_mb_eeprom_iface> sptr; virtual ~x300_mb_eeprom_iface(void) = 0; diff --git a/host/lib/usrp/x300/x300_pcie_mgr.cpp b/host/lib/usrp/x300/x300_pcie_mgr.cpp index 6560f2770..8466a5174 100644 --- a/host/lib/usrp/x300/x300_pcie_mgr.cpp +++ b/host/lib/usrp/x300/x300_pcie_mgr.cpp @@ -58,7 +58,7 @@ using namespace uhd::niusrprio; // We need a zpu xport registry to ensure synchronization between the static // finder method and the instances of the x300_impl class. -typedef std::unordered_map<std::string, boost::weak_ptr<uhd::wb_iface>> +typedef std::unordered_map<std::string, std::weak_ptr<uhd::wb_iface>> pcie_zpu_iface_registry_t; UHD_SINGLETON_FCN(pcie_zpu_iface_registry_t, get_pcie_zpu_iface_registry) static std::mutex pcie_zpu_iface_registry_mutex; @@ -249,7 +249,7 @@ wb_iface::sptr pcie_manager::get_ctrl_iface() "Someone else has a ZPU transport to the device open. Internal error!"); } auto zpu_ctrl = x300_make_ctrl_iface_pcie(_rio_fpga_interface->get_kernel_proxy()); - get_pcie_zpu_iface_registry()[_resource] = boost::weak_ptr<wb_iface>(zpu_ctrl); + get_pcie_zpu_iface_registry()[_resource] = std::weak_ptr<wb_iface>(zpu_ctrl); return zpu_ctrl; } diff --git a/host/lib/usrp/x300/x300_radio_control.cpp b/host/lib/usrp/x300/x300_radio_control.cpp index 6cee57827..8e4351d65 100644 --- a/host/lib/usrp/x300/x300_radio_control.cpp +++ b/host/lib/usrp/x300/x300_radio_control.cpp @@ -28,7 +28,7 @@ #include <uhdlib/usrp/cores/spi_core_3000.hpp> #include <uhdlib/usrp/cores/tx_frontend_core_200.hpp> #include <boost/algorithm/string.hpp> -#include <boost/make_shared.hpp> +#include <memory> #include <algorithm> #include <chrono> #include <functional> @@ -1492,7 +1492,7 @@ private: // create a new dboard manager RFNOC_LOG_TRACE("Creating DB interface..."); - _db_iface = boost::make_shared<x300_dboard_iface>(db_config); + _db_iface = std::make_shared<x300_dboard_iface>(db_config); RFNOC_LOG_TRACE("Creating DB manager..."); _db_manager = dboard_manager::make(_db_eeproms[RX_EEPROM_ADDR + DB_OFFSET], _db_eeproms[TX_EEPROM_ADDR + DB_OFFSET], @@ -1889,7 +1889,7 @@ private: //! Reference to DB manager usrp::dboard_manager::sptr _db_manager; //! Reference to DB iface - boost::shared_ptr<x300_dboard_iface> _db_iface; + std::shared_ptr<x300_dboard_iface> _db_iface; enum radio_connection_t { PRIMARY, SECONDARY }; radio_connection_t _radio_type; |