From 3b59529e71549976eaa99b75f40df732a8b73d6d Mon Sep 17 00:00:00 2001 From: Martin Braun Date: Fri, 10 Apr 2020 11:39:42 -0700 Subject: multi_usrp: Approximate legacy behaviour for recv_async_msg() When using multi_usrp with an RFNoC device, the previous behaviour was to throw an exception when calling recv_async_msg() so users would know they're not supposed to call it (calling tx_stream::recv_async_msg is preferred). However, this breaks too many existing applications. Instead, we keep a weak pointer to the streamer, the same way that older devices do, and query the async message from that. This means that calling recv_async_msg() when there are multiple streamers can lead to unexpected behaviour, but that's a general issue with multi_usrp::recv_async_msg() and this way, the RFNoC devices now behave like older devices do. --- host/lib/usrp/multi_usrp_rfnoc.cpp | 34 +++++++++++++++++++++++++++++----- 1 file changed, 29 insertions(+), 5 deletions(-) (limited to 'host/lib') diff --git a/host/lib/usrp/multi_usrp_rfnoc.cpp b/host/lib/usrp/multi_usrp_rfnoc.cpp index f81253997..14b5fd50b 100644 --- a/host/lib/usrp/multi_usrp_rfnoc.cpp +++ b/host/lib/usrp/multi_usrp_rfnoc.cpp @@ -56,6 +56,7 @@ constexpr char DEFAULT_CPU_FORMAT[] = "fc32"; constexpr char DEFAULT_OTW_FORMAT[] = "sc16"; constexpr double RX_SIGN = +1.0; constexpr double TX_SIGN = -1.0; +constexpr char LOG_ID[] = "MULTI_USRP"; //! A faux container for a UHD device // @@ -64,7 +65,10 @@ constexpr double TX_SIGN = -1.0; // similar functionalities; these can be faked with this redirector class. // // The only exception is recv_async_msg(), which depends on the streamer. It -// will throw a uhd::runtime_error now. +// will print a warning once, and will attempt to access a Tx streamer if it +// has access to a Tx streamer. If there is only ever one Tx streamer, this will +// work as expected. For multiple streamers, only the last streamer's async +// messages will make it through. class redirector_device : public uhd::device { public: @@ -77,13 +81,22 @@ public: tx_streamer::sptr get_tx_stream(const stream_args_t& args) { - return _musrp->get_tx_stream(args); + auto streamer = _musrp->get_tx_stream(args); + _last_tx_streamer = streamer; + return streamer; } - bool recv_async_msg(async_metadata_t&, double) + bool recv_async_msg(async_metadata_t& md, double timeout) { - throw uhd::runtime_error( - "uhd::device::recv_async_msg() cannot be called on this device type!"); + std::call_once(_async_warning_flag, []() { + UHD_LOG_WARNING(LOG_ID, + "Calling multi_usrp::recv_async_msg() is deprecated and can lead to " + "unexpected behaviour. Prefer calling tx_stream::recv_async_msg()."); + }); + auto streamer = _last_tx_streamer.lock(); + if (streamer) { + return streamer->recv_async_msg(md, timeout); + } return false; } @@ -97,7 +110,14 @@ public: return USRP; } + void set_tx_stream(tx_streamer::sptr streamer) + { + _last_tx_streamer = streamer; + } + private: + std::once_flag _async_warning_flag; + std::weak_ptr _last_tx_streamer; multi_usrp* _musrp; }; @@ -380,6 +400,10 @@ public: } } } + // For legacy purposes: This enables recv_async_msg(), which is considered + // deprecated, but as long as it's there, we need this to approximate + // previous behaviour. + _device->set_tx_stream(tx_streamer); return tx_streamer; } -- cgit v1.2.3