struct timespec TimeBase::systemTimespec() const { #ifdef _SYSTEM_LXRT_33_ if (os::isThisLxrtTask()) { struct timespec time = timespec(); struct timespec global_now; os::gettimeofday(&global_now); RTIME rtime_rtai_now = rt_get_time(); RTIME rtime_global_now = timespec2count(&global_now); RTIME rtime_time = timespec2count(&time); count2timespec(rtime_time + rtime_rtai_now - rtime_global_now, &time); return time; } else { #endif return timespec(); #ifdef _SYSTEM_LXRT_33_ } #endif }
void timerfdObj::set_periodically(const timespec &it_interval, struct itimerspec *curr_value) { std::lock_guard<std::mutex> lock(objmutex); get_curr_value(curr_value); if (it_interval.tv_sec == 0 && it_interval.tv_nsec == 0) { errno=EINVAL; timerfd_settime_failed(); } struct kevent kev; EV_SET(&kev, 0, EVFILT_TIMER, EV_ADD, 0, it_interval.tv_sec * 1000 + it_interval.tv_nsec / 1000000, NULL); if (KEVENT_POLL(filedesc, &kev, 1, NULL, 0) < 0) throw SYSEXCEPTION("kevent"); timerfd_set=true; timerfd_value=timespec(); timerfd_interval=it_interval; }
struct itimerspec timerfdObj::kqueue_gettime_locked() { struct itimerspec its; its.it_value=its.it_interval=timespec(); if (timerfd_set) { // Punt for a periodic timer if (timerfd_interval.tv_sec == 0 && timerfd_interval.tv_nsec == 0) { timespec ts=timespec::getclock(timerfd_clock); if (ts < timerfd_value) its.it_value=timerfd_value - ts; } its.it_interval=timerfd_interval; } return its; }
EXPORT_API U32 udpGetHighPrecisionTime() { timespec spec = timespec(); clock_gettime(CLOCK_MONOTONIC, &spec); return (spec.tv_sec * 1000) + (spec.tv_nsec / 1000 / 1000); }
/** * Create a new UHPacket, using an external buffer allocated from * within a MemoryBatch for the packet content storage. This * constructor must be used with placement-new, and requires the * memory in m_buffer to be contiguously allocated with this object. * * This constructor is used by alloc_msg_from_buffer() in * MemoryBatch.hpp; Blocks should use that interface instead. * * The Packet's layer 2, 3, and 4 headers will be parsed on demand. * * @param buf_displace offset from *this to the first byte of * the packet buffer (should be sizeof(Packet)), unless * called from a derived class * @param uh_buf const_buffer pointing to length and bounds of the * buffer to copy the packet from. * @param uh_id Version of UH packet */ UHPacket(memory_not_owned_t, size_t buf_displace, const const_buffer<uint8_t> &uh_buf, int uh_id) : Packet(memory_not_owned, sizeof(Packet), const_buffer<uint8_t>(), timespec(), 0, 0, MSG_ID(Packet)) { parse_uh(uh_buf); }
void timerfdObj::set(int flags, const timespec &it_value, struct itimerspec *curr_value) { std::lock_guard<std::mutex> lock(objmutex); get_curr_value(curr_value); timespec ts=it_value; if (flags & TFD_TIMER_ABSTIME) { timespec now=timespec::getclock(timerfd_clock); if (now >= ts) { ts=timespec(); } else { ts=it_value - now; } } struct kevent kev; EV_SET(&kev, 0, EVFILT_TIMER, EV_ADD | EV_ONESHOT, 0, ts.tv_sec * 1000 + ts.tv_nsec / 1000000, NULL); if (kev.data == 0) kev.data=1; ts=it_value; if (!(flags & TFD_TIMER_ABSTIME)) ts += timespec::getclock(timerfd_clock); if (KEVENT_POLL(filedesc, &kev, 1, NULL, 0) < 0) throw SYSEXCEPTION("kevent"); timerfd_set=true; timerfd_value=it_value; timerfd_interval=timespec(); }
struct timespec timeval2timespec(const struct timeval* tv) { if (!tv) { return timespec(); } struct timespec ts; ts.tv_sec = tv->tv_sec; ts.tv_nsec = tv->tv_usec * 1000; return ts; }
struct timespec mstime2timespec(time64_t mst) { if (mst < 0) { return timespec(); } timespec ts; ts.tv_sec = mst / 1000; ts.tv_nsec = (mst % 1000) * 1000000; return ts; }
void timerfdObj::set(int flags, const timespec &it_value, struct itimerspec *curr_value) { struct itimerspec dummy; struct itimerspec its; its.it_value=it_value; its.it_interval=timespec(); if (!curr_value) curr_value= &dummy; if (timerfd_settime(filedesc, flags, &its, curr_value) < 0) timerfd_settime_failed(); }
struct timespec TimeBase::Timespec() const { return timespec(); }
/** * Create a new UHPacket, copying the packet content from an existing * buffer to an internal buffer owned by the UHPacket. * * FIXME consider replacing the packet buffer here with a slab * allocator. * * @param uh_buf const_buffer pointing to length and bounds of the * buffer to copy the packet from. * @param uh_id Version of UH packet * */ UHPacket(const const_buffer<uint8_t> &uh_buf, int uh_id) : Packet(const_buffer<uint8_t>(), timespec(), 0, 0, MSG_ID(Packet)) { parse_uh(uh_buf); }
//! Default constructor timer() :running(false),cstart(0),cstop(0) { tsstart = timespec(); tsstop = timespec(); }
void timerfdObj::cancel() { set(0, timespec()); }