bool isRecvReady(const Poco::Timespan &timeout) { struct timeval tv; tv.tv_sec = timeout.seconds(); tv.tv_usec = timeout.microseconds(); if (not connected) { UDT::UDSET readfds; UD_SET(serverSock, &readfds); if (UDT::select(1, &readfds, nullptr, nullptr, &tv) != 1) return false; sockaddr addr; int addrlen = sizeof(addr); this->clientSock = UDT::accept(this->serverSock, &addr, &addrlen); if (addrlen == 0) { throw Pothos::RuntimeException("UDT::accept()", UDT::getlasterror().getErrorMessage()); } this->connected = true; return false; } UDT::UDSET readfds; UD_SET(clientSock, &readfds); return UDT::select(1, &readfds, nullptr, nullptr, &tv) == 1; }
void ThreadTest::testSleep() { Poco::Timestamp start; Thread::sleep(200); Poco::Timespan elapsed = start.elapsed(); assert (elapsed.totalMilliseconds() >= 190 && elapsed.totalMilliseconds() < 250); }
void SocketImpl::setOption(int level, int option, const Poco::Timespan& value) { struct timeval tv; tv.tv_sec = (long) value.totalSeconds(); tv.tv_usec = (long) value.useconds(); setRawOption(level, option, &tv, sizeof(tv)); }
bool Debounce(int dtime) { const Poco::Timespan TimeOut(0, 1000*dtime); if (fpsTimeLast.isElapsed(TimeOut.totalMicroseconds())) { fpsTimeLast.update(); return true; } else { return false; } }
//-------------------------------------------------------------- int Timeline::M_getElapsedSeconds() { Poco::DateTime now = nowLocal(); if (now > m_dateStart){ Poco::Timespan delta = now-m_dateStart; return delta.totalSeconds(); } return 0; }
Command Command::set(const std::string& key, const std::string& value, bool overwrite, const Poco::Timespan& expireTime, bool create) { Command cmd("SET"); cmd << key << value; if (! overwrite) cmd << "NX"; if (! create) cmd << "XX"; if (expireTime.totalMicroseconds() > 0) cmd << "PX" << expireTime.totalMilliseconds(); return cmd; }
void SocketImpl::getOption(int level, int option, Poco::Timespan& value) { struct timeval tv; poco_socklen_t len = sizeof(tv); getRawOption(level, option, &tv, len); value.assign(tv.tv_sec, tv.tv_usec); }
int SerialPortImpl::pollImpl(char* buffer, std::size_t size, const Poco::Timespan& timeout) { COMMTIMEOUTS prevCTO; if (!GetCommTimeouts(_handle, &prevCTO)) { throw Poco::IOException("error getting serial port timeouts"); } COMMTIMEOUTS cto; cto.ReadIntervalTimeout = CHARACTER_TIMEOUT; cto.ReadTotalTimeoutConstant = static_cast<DWORD>(timeout.totalMilliseconds()); cto.ReadTotalTimeoutMultiplier = 0; cto.WriteTotalTimeoutConstant = MAXDWORD; cto.WriteTotalTimeoutMultiplier = 0; if (!SetCommTimeouts(_handle, &cto)) { throw Poco::IOException("error setting serial port timeouts on serial port"); } try { DWORD bytesRead = 0; if (!ReadFile(_handle, buffer, size, &bytesRead, NULL)) { throw Poco::IOException("failed to read from serial port"); } SetCommTimeouts(_handle, &prevCTO); return (bytesRead == 0) ? -1 : bytesRead; } catch (...) { SetCommTimeouts(_handle, &prevCTO); throw; } }
void SocketImpl::setSendTimeout(const Poco::Timespan& timeout) { #if defined(_WIN32) && !defined(POCO_BROKEN_TIMEOUTS) int value = (int) timeout.totalMilliseconds(); setOption(SOL_SOCKET, SO_SNDTIMEO, value); #elif defined(POCO_BROKEN_TIMEOUTS) _sndTimeout = timeout; #else setOption(SOL_SOCKET, SO_SNDTIMEO, timeout); #endif }
Frame::Ptr FrameQueue::dequeueFrame(Poco::Timespan timeout) { Frame::Ptr pFrame; if (_sema.tryWait(static_cast<long>(timeout.totalMilliseconds()))) { Poco::FastMutex::ScopedLock lock(_mutex); pFrame = _queue.front(); _queue.pop_front(); } return pFrame; }
void SocketImpl::setReceiveTimeout(const Poco::Timespan& timeout) { #ifndef POCO_BROKEN_TIMEOUTS #if defined(_WIN32) int value = (int) timeout.totalMilliseconds(); setOption(SOL_SOCKET, SO_RCVTIMEO, value); #else setOption(SOL_SOCKET, SO_RCVTIMEO, timeout); #endif #else _recvTimeout = timeout; #endif }
void QuotaForInterval::checkAndAddExecutionTime(time_t current_time, const String & quota_name, const String & user_name, Poco::Timespan amount) { /// Information about internals of Poco::Timespan used. used.execution_time_usec += amount.totalMicroseconds(); checkExceeded(current_time, quota_name, user_name); }
bool MapWindow::RenderTimeAvailable() { const Poco::Timespan RenderInterval(0, 700*1000); // 700ms // it's been less than 700 ms since last data was posted return !MapDirty && !timestamp_newdata.isElapsed(RenderInterval.totalMicroseconds()); }
int Socket::select(SocketList& readList, SocketList& writeList, SocketList& exceptList, const Poco::Timespan& timeout) { #if defined(POCO_HAVE_FD_EPOLL) int epollSize = readList.size() + writeList.size() + exceptList.size(); if (epollSize == 0) return 0; int epollfd = -1; { struct epoll_event eventsIn[epollSize]; memset(eventsIn, 0, sizeof(eventsIn)); struct epoll_event* eventLast = eventsIn; for (SocketList::iterator it = readList.begin(); it != readList.end(); ++it) { poco_socket_t sockfd = it->sockfd(); if (sockfd != POCO_INVALID_SOCKET) { struct epoll_event* e = eventsIn; for (; e != eventLast; ++e) { if (reinterpret_cast<Socket*>(e->data.ptr)->sockfd() == sockfd) break; } if (e == eventLast) { e->data.ptr = &(*it); ++eventLast; } e->events |= EPOLLIN; } } for (SocketList::iterator it = writeList.begin(); it != writeList.end(); ++it) { poco_socket_t sockfd = it->sockfd(); if (sockfd != POCO_INVALID_SOCKET) { struct epoll_event* e = eventsIn; for (; e != eventLast; ++e) { if (reinterpret_cast<Socket*>(e->data.ptr)->sockfd() == sockfd) break; } if (e == eventLast) { e->data.ptr = &(*it); ++eventLast; } e->events |= EPOLLOUT; } } for (SocketList::iterator it = exceptList.begin(); it != exceptList.end(); ++it) { poco_socket_t sockfd = it->sockfd(); if (sockfd != POCO_INVALID_SOCKET) { struct epoll_event* e = eventsIn; for (; e != eventLast; ++e) { if (reinterpret_cast<Socket*>(e->data.ptr)->sockfd() == sockfd) break; } if (e == eventLast) { e->data.ptr = &(*it); ++eventLast; } e->events |= EPOLLERR; } } epollSize = eventLast - eventsIn; epollfd = epoll_create(epollSize); if (epollfd < 0) { char buf[1024]; strerror_r(errno, buf, sizeof(buf)); SocketImpl::error(std::string("Can't create epoll queue: ") + buf); } for (struct epoll_event* e = eventsIn; e != eventLast; ++e) { poco_socket_t sockfd = reinterpret_cast<Socket*>(e->data.ptr)->sockfd(); if (sockfd != POCO_INVALID_SOCKET) { if (epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, e) < 0) { char buf[1024]; strerror_r(errno, buf, sizeof(buf)); ::close(epollfd); SocketImpl::error(std::string("Can't insert socket to epoll queue: ") + buf); } } } } struct epoll_event eventsOut[epollSize]; memset(eventsOut, 0, sizeof(eventsOut)); Poco::Timespan remainingTime(timeout); int rc; do { Poco::Timestamp start; rc = epoll_wait(epollfd, eventsOut, epollSize, remainingTime.totalMilliseconds()); if (rc < 0 && SocketImpl::lastError() == POCO_EINTR) { Poco::Timestamp end; Poco::Timespan waited = end - start; if (waited < remainingTime) remainingTime -= waited; else remainingTime = 0; } } while (rc < 0 && SocketImpl::lastError() == POCO_EINTR); ::close(epollfd); if (rc < 0) SocketImpl::error(); SocketList readyReadList; SocketList readyWriteList; SocketList readyExceptList; for (int n = 0; n < rc; ++n) { if (eventsOut[n].events & EPOLLERR) readyExceptList.push_back(*reinterpret_cast<Socket*>(eventsOut[n].data.ptr)); if (eventsOut[n].events & EPOLLIN) readyReadList.push_back(*reinterpret_cast<Socket*>(eventsOut[n].data.ptr)); if (eventsOut[n].events & EPOLLOUT) readyWriteList.push_back(*reinterpret_cast<Socket*>(eventsOut[n].data.ptr)); } std::swap(readList, readyReadList); std::swap(writeList, readyWriteList); std::swap(exceptList, readyExceptList); return readList.size() + writeList.size() + exceptList.size(); #elif defined(POCO_HAVE_FD_POLL) nfds_t nfd = readList.size() + writeList.size() + exceptList.size(); if (0 == nfd) return 0; SharedPollArray pPollArr = new pollfd[nfd]; int idx = 0; for (SocketList::iterator it = readList.begin(); it != readList.end(); ++it) { pPollArr[idx].fd = int(it->sockfd()); pPollArr[idx++].events |= POLLIN; } SocketList::iterator begR = readList.begin(); SocketList::iterator endR = readList.end(); for (SocketList::iterator it = writeList.begin(); it != writeList.end(); ++it) { SocketList::iterator pos = std::find(begR, endR, *it); if (pos != endR) { pPollArr[pos-begR].events |= POLLOUT; --nfd; } else { pPollArr[idx].fd = int(it->sockfd()); pPollArr[idx++].events |= POLLOUT; } } SocketList::iterator begW = writeList.begin(); SocketList::iterator endW = writeList.end(); for (SocketList::iterator it = exceptList.begin(); it != exceptList.end(); ++it) { SocketList::iterator pos = std::find(begR, endR, *it); if (pos != endR) --nfd; else { SocketList::iterator pos = std::find(begW, endW, *it); if (pos != endW) --nfd; else pPollArr[idx++].fd = int(it->sockfd()); } } Poco::Timespan remainingTime(timeout); int rc; do { Poco::Timestamp start; rc = ::poll(pPollArr, nfd, timeout.totalMilliseconds()); if (rc < 0 && SocketImpl::lastError() == POCO_EINTR) { Poco::Timestamp end; Poco::Timespan waited = end - start; if (waited < remainingTime) remainingTime -= waited; else remainingTime = 0; } } while (rc < 0 && SocketImpl::lastError() == POCO_EINTR); if (rc < 0) SocketImpl::error(); SocketList readyReadList; SocketList readyWriteList; SocketList readyExceptList; SocketList::iterator begE = exceptList.begin(); SocketList::iterator endE = exceptList.end(); for (int idx = 0; idx < nfd; ++idx) { SocketList::iterator slIt = std::find_if(begR, endR, Socket::FDCompare(pPollArr[idx].fd)); if (POLLIN & pPollArr[idx].revents && slIt != endR) readyReadList.push_back(*slIt); slIt = std::find_if(begW, endW, Socket::FDCompare(pPollArr[idx].fd)); if (POLLOUT & pPollArr[idx].revents && slIt != endW) readyWriteList.push_back(*slIt); slIt = std::find_if(begE, endE, Socket::FDCompare(pPollArr[idx].fd)); if (POLLERR & pPollArr[idx].revents && slIt != endE) readyExceptList.push_back(*slIt); } std::swap(readList, readyReadList); std::swap(writeList, readyWriteList); std::swap(exceptList, readyExceptList); return readList.size() + writeList.size() + exceptList.size(); #else fd_set fdRead; fd_set fdWrite; fd_set fdExcept; int nfd = 0; FD_ZERO(&fdRead); for (SocketList::const_iterator it = readList.begin(); it != readList.end(); ++it) { poco_socket_t fd = it->sockfd(); if (fd != POCO_INVALID_SOCKET) { if (int(fd) > nfd) nfd = int(fd); FD_SET(fd, &fdRead); } } FD_ZERO(&fdWrite); for (SocketList::const_iterator it = writeList.begin(); it != writeList.end(); ++it) { poco_socket_t fd = it->sockfd(); if (fd != POCO_INVALID_SOCKET) { if (int(fd) > nfd) nfd = int(fd); FD_SET(fd, &fdWrite); } } FD_ZERO(&fdExcept); for (SocketList::const_iterator it = exceptList.begin(); it != exceptList.end(); ++it) { poco_socket_t fd = it->sockfd(); if (fd != POCO_INVALID_SOCKET) { if (int(fd) > nfd) nfd = int(fd); FD_SET(fd, &fdExcept); } } if (nfd == 0) return 0; Poco::Timespan remainingTime(timeout); int rc; do { struct timeval tv; tv.tv_sec = (long) remainingTime.totalSeconds(); tv.tv_usec = (long) remainingTime.useconds(); Poco::Timestamp start; rc = ::select(nfd + 1, &fdRead, &fdWrite, &fdExcept, &tv); if (rc < 0 && SocketImpl::lastError() == POCO_EINTR) { Poco::Timestamp end; Poco::Timespan waited = end - start; if (waited < remainingTime) remainingTime -= waited; else remainingTime = 0; } } while (rc < 0 && SocketImpl::lastError() == POCO_EINTR); if (rc < 0) SocketImpl::error(); SocketList readyReadList; for (SocketList::const_iterator it = readList.begin(); it != readList.end(); ++it) { poco_socket_t fd = it->sockfd(); if (fd != POCO_INVALID_SOCKET) { if (FD_ISSET(fd, &fdRead)) readyReadList.push_back(*it); } } std::swap(readList, readyReadList); SocketList readyWriteList; for (SocketList::const_iterator it = writeList.begin(); it != writeList.end(); ++it) { poco_socket_t fd = it->sockfd(); if (fd != POCO_INVALID_SOCKET) { if (FD_ISSET(fd, &fdWrite)) readyWriteList.push_back(*it); } } std::swap(writeList, readyWriteList); SocketList readyExceptList; for (SocketList::const_iterator it = exceptList.begin(); it != exceptList.end(); ++it) { poco_socket_t fd = it->sockfd(); if (fd != POCO_INVALID_SOCKET) { if (FD_ISSET(fd, &fdExcept)) readyExceptList.push_back(*it); } } std::swap(exceptList, readyExceptList); return rc; #endif // POCO_HAVE_FD_EPOLL }