aboutsummaryrefslogtreecommitdiffstats
path: root/host/lib/rfnoc/ctrl_iface.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'host/lib/rfnoc/ctrl_iface.cpp')
-rw-r--r--host/lib/rfnoc/ctrl_iface.cpp116
1 files changed, 20 insertions, 96 deletions
diff --git a/host/lib/rfnoc/ctrl_iface.cpp b/host/lib/rfnoc/ctrl_iface.cpp
index b2ac1778e..3a16f7ec1 100644
--- a/host/lib/rfnoc/ctrl_iface.cpp
+++ b/host/lib/rfnoc/ctrl_iface.cpp
@@ -16,9 +16,8 @@
//
#include "ctrl_iface.hpp"
-#include "async_packet_handler.hpp"
#include <uhd/exception.hpp>
-#include <uhd/utils/msg.hpp>
+
#include <uhd/utils/byteswap.hpp>
#include <uhd/utils/safe_call.hpp>
#include <uhd/transport/bounded_buffer.hpp>
@@ -37,7 +36,6 @@ using namespace uhd::transport;
static const double ACK_TIMEOUT = 2.0; //supposed to be worst case practical timeout
static const double MASSIVE_TIMEOUT = 10.0; //for when we wait on a timed command
-static const size_t SR_READBACK = 32;
ctrl_iface::~ctrl_iface(void){
/* NOP */
@@ -60,13 +58,12 @@ public:
_name(name),
_seq_out(0),
_timeout(ACK_TIMEOUT),
- _resp_queue(128/*max response msgs*/),
- _resp_queue_size(_resp_xport ? _resp_xport->get_num_recv_frames() : 3),
+ _resp_queue_size(_resp_xport->get_num_recv_frames()),
_rb_address(uhd::rfnoc::SR_READBACK)
{
- if (resp_xport) {
- while (resp_xport->get_recv_buff(0.0)) {} //flush
- }
+ UHD_ASSERT_THROW(_ctrl_xport);
+ UHD_ASSERT_THROW(_resp_xport);
+ while (resp_xport->get_recv_buff(0.0)) {} //flush
this->set_time(uhd::time_spec_t(0.0));
this->set_tick_rate(1.0); //something possible but bogus
}
@@ -76,7 +73,6 @@ public:
_timeout = ACK_TIMEOUT; //reset timeout to something small
UHD_SAFE_CALL(
this->peek32(0);//dummy peek with the purpose of ack'ing all packets
- _async_task.reset();//now its ok to release the task
)
}
@@ -172,7 +168,7 @@ private:
//load payload
pkt[packet_info.num_header_words32+0] = (_bige)? uhd::htonx(addr) : uhd::htowx(addr);
pkt[packet_info.num_header_words32+1] = (_bige)? uhd::htonx(data) : uhd::htowx(data);
- //UHD_MSG(status) << boost::format("0x%08x, 0x%08x\n") % addr % data;
+ //UHD_LOGGER_INFO("RFNOC") << boost::format("0x%08x, 0x%08x\n") % addr % data;
//send the buffer over the interface
_outstanding_seqs.push(_seq_out);
buff->commit(sizeof(uint32_t)*(packet_info.num_packet_words32));
@@ -196,50 +192,16 @@ private:
uint32_t const *pkt = NULL;
managed_recv_buffer::sptr buff;
- //get buffer from response endpoint - or die in timeout
- if (_resp_xport)
- {
- buff = _resp_xport->get_recv_buff(_timeout);
- try
- {
- UHD_ASSERT_THROW(bool(buff));
- UHD_ASSERT_THROW(buff->size() > 0);
- }
- catch(const std::exception &ex)
- {
- throw uhd::io_error(str(boost::format("Block ctrl (%s) no response packet - %s") % _name % ex.what()));
- }
- pkt = buff->cast<const uint32_t *>();
- packet_info.num_packet_words32 = buff->size()/sizeof(uint32_t);
+ buff = _resp_xport->get_recv_buff(_timeout);
+ try {
+ UHD_ASSERT_THROW(bool(buff));
+ UHD_ASSERT_THROW(buff->size() > 0);
}
-
- //get buffer from response endpoint - or die in timeout
- else
- {
- /*
- * Couldn't get message with haste.
- * Now check both possible queues for messages.
- * Messages should come in on _resp_queue,
- * but could end up in dump_queue.
- * If we don't get a message --> Die in timeout.
- */
- double accum_timeout = 0.0;
- const double short_timeout = 0.005; // == 5ms
- while(not ((_resp_queue.pop_with_haste(resp_buff))
- || (check_dump_queue(resp_buff))
- || (_resp_queue.pop_with_timed_wait(resp_buff, short_timeout))
- )){
- /*
- * If a message couldn't be received within a given timeout
- * --> throw AssertionError!
- */
- accum_timeout += short_timeout;
- UHD_ASSERT_THROW(accum_timeout < _timeout);
- }
-
- pkt = resp_buff.data;
- packet_info.num_packet_words32 = sizeof(resp_buff)/sizeof(uint32_t);
+ catch(const std::exception &ex) {
+ throw uhd::io_error(str(boost::format("Block ctrl (%s) no response packet - %s") % _name % ex.what()));
}
+ pkt = buff->cast<const uint32_t *>();
+ packet_info.num_packet_words32 = buff->size()/sizeof(uint32_t);
//parse the buffer
try
@@ -250,15 +212,15 @@ private:
}
catch(const std::exception &ex)
{
- UHD_MSG(error) << "[" << _name << "] Block ctrl bad VITA packet: " << ex.what() << std::endl;
+ UHD_LOGGER_ERROR("RFNOC") << "[" << _name << "] Block ctrl bad VITA packet: " << ex.what() ;
if (buff){
- UHD_MSG(status) << boost::format("%08X") % pkt[0] << std::endl;
- UHD_MSG(status) << boost::format("%08X") % pkt[1] << std::endl;
- UHD_MSG(status) << boost::format("%08X") % pkt[2] << std::endl;
- UHD_MSG(status) << boost::format("%08X") % pkt[3] << std::endl;
+ UHD_LOGGER_INFO("RFNOC") << boost::format("%08X") % pkt[0] ;
+ UHD_LOGGER_INFO("RFNOC") << boost::format("%08X") % pkt[1] ;
+ UHD_LOGGER_INFO("RFNOC") << boost::format("%08X") % pkt[2] ;
+ UHD_LOGGER_INFO("RFNOC") << boost::format("%08X") % pkt[3] ;
}
else{
- UHD_MSG(status) << "buff is NULL" << std::endl;
+ UHD_LOGGER_INFO("RFNOC") << "buff is NULL" ;
}
}
@@ -306,48 +268,11 @@ private:
return 0;
}
- /*
- * If ctrl_core waits for a message that didn't arrive it can search for it in the dump queue.
- * This actually happens during shutdown.
- * handle_async_task can't access queue anymore thus it returns the corresponding message.
- * msg_task class implements a dump_queue to store such messages.
- * With check_dump_queue we can check if a message we are waiting for got stranded there.
- * If a message got stuck we get it here and push it onto our own message_queue.
- */
- bool check_dump_queue(resp_buff_type& b) {
- const size_t min_buff_size = 8; // Same value as in b200_io_impl->handle_async_task
- uint32_t recv_sid = (((_sid)<<16)|((_sid)>>16));
- uhd::msg_task::msg_payload_t msg;
- do{
- msg = _async_task->get_msg_from_dump_queue(recv_sid);
- }
- while(msg.size() < min_buff_size && msg.size() != 0);
-
- if(msg.size() >= min_buff_size) {
- memcpy(b.data, &msg.front(), std::min(msg.size(), sizeof(b.data)));
- return true;
- }
- return false;
- }
-
- void push_response(const uint32_t *buff)
- {
- resp_buff_type resp_buff;
- std::memcpy(resp_buff.data, buff, sizeof(resp_buff));
- _resp_queue.push_with_haste(resp_buff);
- }
-
- void hold_task(uhd::msg_task::sptr task)
- {
- _async_task = task;
- }
-
const vrt::if_packet_info_t::link_type_t _link_type;
const vrt::if_packet_info_t::packet_type_t _packet_type;
const bool _bige;
const uhd::transport::zero_copy_if::sptr _ctrl_xport;
const uhd::transport::zero_copy_if::sptr _resp_xport;
- uhd::msg_task::sptr _async_task;
const uint32_t _sid;
const std::string _name;
boost::mutex _mutex;
@@ -357,7 +282,6 @@ private:
double _tick_rate;
double _timeout;
std::queue<size_t> _outstanding_seqs;
- bounded_buffer<resp_buff_type> _resp_queue;
const size_t _resp_queue_size;
const size_t _rb_address;
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 17:52:10 +0000