46 #include <boost/python.hpp>
47namespace bp = boost::python;
51rpu::ClientPtr rpu::Client::create(std::string host, uint16_t port,
bool jumbo) {
52 rpu::ClientPtr r = std::make_shared<rpu::Client>(host, port, jumbo);
57rpu::Client::Client(std::string host, uint16_t port,
bool jumbo) :
rpu::
Core(jumbo) {
58 struct addrinfo aiHints;
59 struct addrinfo* aiList = 0;
60 const sockaddr_in* addr;
70 std::shared_ptr<int> scopePtr = std::make_shared<int>(0);
73 if ((
fd_ = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
75 "Failed to create socket for port %" PRIu16
" at address %s",
80 bzero(&aiHints,
sizeof(aiHints));
81 aiHints.ai_flags = AI_CANONNAME;
82 aiHints.ai_family = AF_INET;
83 aiHints.ai_socktype = SOCK_DGRAM;
84 aiHints.ai_protocol = IPPROTO_UDP;
87 if (::getaddrinfo(address_.c_str(), 0, &aiHints, &aiList) != 0 || aiList ==
nullptr) {
93 addr = (
const sockaddr_in*)(aiList->ai_addr);
96 memset(&
remAddr_, 0,
sizeof(
struct sockaddr_in));
97 ((
struct sockaddr_in*)(&
remAddr_))->sin_family = AF_INET;
98 ((
struct sockaddr_in*)(&
remAddr_))->sin_addr.s_addr = addr->sin_addr.s_addr;
99 ((
struct sockaddr_in*)(&
remAddr_))->sin_port = htons(port_);
101 ::freeaddrinfo(aiList);
108 udpLog_->debug(
"UDP client ready. remote=%s:%" PRIu16
", maxPayload=%" PRIu32,
115 thread_ =
new std::thread(&rpu::Client::runThread,
this, std::weak_ptr<int>(scopePtr));
125 pthread_setname_np(
thread_->native_handle(),
"UdpClient");
130rpu::Client::~Client() {
134void rpu::Client::stop() {
146 udpLog_->debug(
"Stopping UDP client for remote %s:%" PRIu16, address_.c_str(), port_);
152 ris::Frame::BufferIterator it;
158 struct iovec msg_iov[1];
161 msg.msg_name = &remAddr_;
162 msg.msg_namelen =
sizeof(
struct sockaddr_in);
163 msg.msg_iov = msg_iov;
165 msg.msg_control = NULL;
166 msg.msg_controllen = 0;
171 std::lock_guard<std::mutex> lock(udpMtx_);
174 if (frame->getError()) {
175 udpLog_->warning(
"Dropping errored outbound frame. remote=%s:%" PRIu16
", error=0x%" PRIx8,
183 for (it = frame->beginBuffer(); it != frame->endBuffer(); ++it) {
184 if ((*it)->getPayload() == 0)
break;
187 msg_iov[0].iov_base = (*it)->begin();
188 msg_iov[0].iov_len = (*it)->getPayload();
200 if (select(fd_ + 1, NULL, &fds, NULL, &tout) <= 0) {
201 udpLog_->critical(
"Client::acceptFrame: Timeout waiting for outbound transmit after %" PRIu32
202 ".%" PRIu32
" seconds! May be caused by outbound backpressure.",
206 }
else if ((res = sendmsg(fd_, &msg, 0)) < 0) {
207 udpLog_->warning(
"UDP write call failed for %s: %s", address_.c_str(), std::strerror(errno));
214void rpu::Client::runThread(std::weak_ptr<int> lockPtr) {
223 while (!lockPtr.expired())
continue;
225 udpLog_->logThreadId();
232 ris::Pool::shared_from_this();
234 }
catch (
const std::bad_weak_ptr&) {
235 std::this_thread::sleep_for(std::chrono::milliseconds(1));
238 if (!threadEn_)
return;
241 frame = reqLocalFrame(maxPayload(),
false);
245 buff = *(frame->beginBuffer());
246 avail = buff->getAvailable();
247 res = recvfrom(fd_, buff->begin(), avail, MSG_TRUNC | MSG_DONTWAIT, NULL, 0);
252 udpLog_->warning(
"Receive data was too large. remote=%s:%" PRIu16
", rx=%i, avail=%" PRIu32
259 buff->setPayload(res);
264 frame = reqLocalFrame(maxPayload(),
false);
272 tout.tv_usec = 100000;
274 select(fd_ + 1, &fds, NULL, NULL, &tout);
279void rpu::Client::setup_python() {
282 bp::class_<rpu::Client, rpu::ClientPtr, bp::bases<rpu::Core, ris::Master, ris::Slave>, boost::noncopyable>(
284 bp::init<std::string, uint16_t, bool>());
286 bp::implicitly_convertible<rpu::ClientPtr, rpu::CorePtr>();
287 bp::implicitly_convertible<rpu::ClientPtr, ris::MasterPtr>();
288 bp::implicitly_convertible<rpu::ClientPtr, ris::SlavePtr>();
static GeneralError create(std::string src, const char *fmt,...)
Creates a formatted error instance.
RAII helper that releases the Python GIL for a scope.
static std::shared_ptr< rogue::Logging > create(const std::string &name, bool quiet=false)
Creates a logger instance.
void setFixedSize(uint32_t size)
Sets fixed-size mode.
void setPoolSize(uint32_t size)
Sets buffer pool size.
Shared UDP transport base for stream client/server endpoints.
std::atomic< bool > threadEn_
std::shared_ptr< rogue::Logging > udpLog_
struct sockaddr_in remAddr_
uint32_t maxPayload()
Returns maximum UDP payload size in bytes.
std::shared_ptr< rogue::interfaces::stream::Buffer > BufferPtr
Shared pointer alias for Buffer.
std::shared_ptr< rogue::interfaces::stream::Frame > FramePtr
Shared pointer alias for Frame.
std::shared_ptr< rogue::interfaces::stream::FrameLock > FrameLockPtr
Shared pointer alias for FrameLock.
std::shared_ptr< rogue::protocols::udp::Client > ClientPtr