hires.xs

source of perl for linux application,

	    croak("Time::HiRes::nanosleep(%"NVgf"): negative time not invented yet", nsec);
	sleepfor.tv_sec = (Time_t)(nsec / 1e9);
	sleepfor.tv_nsec = (long)(nsec - ((NV)sleepfor.tv_sec) * 1e9);
	if (!nanosleep(&sleepfor, &unslept)) {
	    RETVAL = nsec;
	} else {
	    sleepfor.tv_sec -= unslept.tv_sec;
	    sleepfor.tv_nsec -= unslept.tv_nsec;
	    if (sleepfor.tv_nsec < 0) {
		sleepfor.tv_sec--;
		sleepfor.tv_nsec += 1000000000;
	    }
	    RETVAL = ((NV)sleepfor.tv_sec) * 1e9 + ((NV)sleepfor.tv_nsec);
	}
    OUTPUT:
	RETVAL

#else  /* #if defined(TIME_HIRES_NANOSLEEP) */

NV
nanosleep(nsec)
        NV nsec
    CODE:
        croak("Time::HiRes::nanosleep(): unimplemented in this platform");
        RETVAL = 0.0;

#endif /* #if defined(TIME_HIRES_NANOSLEEP) */

NV
sleep(...)
	PREINIT:
	struct timeval Ta, Tb;
	CODE:
	gettimeofday(&Ta, NULL);
	if (items > 0) {
	    NV seconds  = SvNV(ST(0));
	    if (seconds >= 0.0) {
	         UV useconds = (UV)(1E6 * (seconds - (UV)seconds));
		 if (seconds >= 1.0)
		     sleep((U32)seconds);
		 if ((IV)useconds < 0) {
#if defined(__sparc64__) && defined(__GNUC__)
		   /* Sparc64 gcc 2.95.3 (e.g. on NetBSD) has a bug
		    * where (0.5 - (UV)(0.5)) will under certain
		    * circumstances (if the double is cast to UV more
		    * than once?) evaluate to -0.5, instead of 0.5. */
		   useconds = -(IV)useconds;
#endif /* #if defined(__sparc64__) && defined(__GNUC__) */
		   if ((IV)useconds < 0)
		     croak("Time::HiRes::sleep(%"NVgf"): internal error: useconds < 0 (unsigned %"UVuf" signed %"IVdf")", seconds, useconds, (IV)useconds);
		 }
		 usleep(useconds);
	    } else
	        croak("Time::HiRes::sleep(%"NVgf"): negative time not invented yet", seconds);
	} else
	    PerlProc_pause();
	gettimeofday(&Tb, NULL);
#if 0
	printf("[%ld %ld] [%ld %ld]\n", Tb.tv_sec, Tb.tv_usec, Ta.tv_sec, Ta.tv_usec);
#endif
	RETVAL = (NV)(Tb.tv_sec-Ta.tv_sec)+0.000001*(NV)(Tb.tv_usec-Ta.tv_usec);

	OUTPUT:
	RETVAL

#else  /* #if defined(HAS_USLEEP) && defined(HAS_GETTIMEOFDAY) */

NV
usleep(useconds)
        NV useconds
    CODE:
        croak("Time::HiRes::usleep(): unimplemented in this platform");
        RETVAL = 0.0;

#endif /* #if defined(HAS_USLEEP) && defined(HAS_GETTIMEOFDAY) */

#ifdef HAS_UALARM

int
ualarm(useconds,interval=0)
	int useconds
	int interval
	CODE:
	if (useconds < 0 || interval < 0)
	    croak("Time::HiRes::ualarm(%d, %d): negative time not invented yet", useconds, interval);
	if (useconds >= IV_1E6 || interval >= IV_1E6)
#if defined(HAS_SETITIMER) && defined(ITIMER_REAL)
		RETVAL = hrt_ualarm_itimer(useconds, interval);
#else
		croak("Time::HiRes::ualarm(%d, %d): useconds or interval equal or more than %"IVdf, useconds, interval, IV_1E6);
#endif
	else
		RETVAL = ualarm(useconds, interval);

	OUTPUT:
	RETVAL

NV
alarm(seconds,interval=0)
	NV seconds
	NV interval
	CODE:
	if (seconds < 0.0 || interval < 0.0)
	    croak("Time::HiRes::alarm(%"NVgf", %"NVgf"): negative time not invented yet", seconds, interval);
	RETVAL = (NV)ualarm((IV)(seconds  * IV_1E6),
			    (IV)(interval * IV_1E6)) / NV_1E6;

	OUTPUT:
	RETVAL

#else

int
ualarm(useconds,interval=0)
	int useconds
	int interval
    CODE:
        croak("Time::HiRes::ualarm(): unimplemented in this platform");
	RETVAL = -1;

NV
alarm(seconds,interval=0)
	NV seconds
	NV interval
    CODE:
        croak("Time::HiRes::alarm(): unimplemented in this platform");
	RETVAL = 0.0;

#endif /* #ifdef HAS_UALARM */

#ifdef HAS_GETTIMEOFDAY
#    ifdef MACOS_TRADITIONAL	/* fix epoch TZ and use unsigned time_t */
void
gettimeofday()
        PREINIT:
        struct timeval Tp;
        struct timezone Tz;
        PPCODE:
        int status;
        status = gettimeofday (&Tp, &Tz);

	if (status == 0) {
	     Tp.tv_sec += Tz.tz_minuteswest * 60;	/* adjust for TZ */
             if (GIMME == G_ARRAY) {
                 EXTEND(sp, 2);
                 /* Mac OS (Classic) has unsigned time_t */
                 PUSHs(sv_2mortal(newSVuv(Tp.tv_sec)));
                 PUSHs(sv_2mortal(newSViv(Tp.tv_usec)));
             } else {
                 EXTEND(sp, 1);
                 PUSHs(sv_2mortal(newSVnv(Tp.tv_sec + (Tp.tv_usec / NV_1E6))));
	     }
        }

NV
time()
        PREINIT:
        struct timeval Tp;
        struct timezone Tz;
        CODE:
        int status;
        status = gettimeofday (&Tp, &Tz);
	if (status == 0) {
            Tp.tv_sec += Tz.tz_minuteswest * 60;	/* adjust for TZ */
	    RETVAL = Tp.tv_sec + (Tp.tv_usec / NV_1E6);
        } else {
	    RETVAL = -1.0;
	}
	OUTPUT:
	RETVAL

#    else	/* MACOS_TRADITIONAL */
void
gettimeofday()
        PREINIT:
        struct timeval Tp;
        PPCODE:
	int status;
        status = gettimeofday (&Tp, NULL);
	if (status == 0) {
	     if (GIMME == G_ARRAY) {
	         EXTEND(sp, 2);
                 PUSHs(sv_2mortal(newSViv(Tp.tv_sec)));
                 PUSHs(sv_2mortal(newSViv(Tp.tv_usec)));
             } else {
                 EXTEND(sp, 1);
                 PUSHs(sv_2mortal(newSVnv(Tp.tv_sec + (Tp.tv_usec / NV_1E6))));
             }
        }

NV
time()
        PREINIT:
        struct timeval Tp;
        CODE:
	int status;
        status = gettimeofday (&Tp, NULL);
	if (status == 0) {
            RETVAL = Tp.tv_sec + (Tp.tv_usec / NV_1E6);
	} else {
	    RETVAL = -1.0;
	}
	OUTPUT:
	RETVAL

#    endif	/* MACOS_TRADITIONAL */
#endif /* #ifdef HAS_GETTIMEOFDAY */

#if defined(HAS_GETITIMER) && defined(HAS_SETITIMER)

#define TV2NV(tv) ((NV)((tv).tv_sec) + 0.000001 * (NV)((tv).tv_usec))

void
setitimer(which, seconds, interval = 0)
	int which
	NV seconds
	NV interval
    PREINIT:
	struct itimerval newit;
	struct itimerval oldit;
    PPCODE:
	if (seconds < 0.0 || interval < 0.0)
	    croak("Time::HiRes::setitimer(%"IVdf", %"NVgf", %"NVgf"): negative time not invented yet", (IV)which, seconds, interval);
	newit.it_value.tv_sec  = (IV)seconds;
	newit.it_value.tv_usec =
	  (IV)((seconds  - (NV)newit.it_value.tv_sec)    * NV_1E6);
	newit.it_interval.tv_sec  = (IV)interval;
	newit.it_interval.tv_usec =
	  (IV)((interval - (NV)newit.it_interval.tv_sec) * NV_1E6);
	if (setitimer(which, &newit, &oldit) == 0) {
	  EXTEND(sp, 1);
	  PUSHs(sv_2mortal(newSVnv(TV2NV(oldit.it_value))));
	  if (GIMME == G_ARRAY) {
	    EXTEND(sp, 1);
	    PUSHs(sv_2mortal(newSVnv(TV2NV(oldit.it_interval))));
	  }
	}

void
getitimer(which)
	int which
    PREINIT:
	struct itimerval nowit;
    PPCODE:
	if (getitimer(which, &nowit) == 0) {
	  EXTEND(sp, 1);
	  PUSHs(sv_2mortal(newSVnv(TV2NV(nowit.it_value))));
	  if (GIMME == G_ARRAY) {
	    EXTEND(sp, 1);
	    PUSHs(sv_2mortal(newSVnv(TV2NV(nowit.it_interval))));
	  }
	}

#endif /* #if defined(HAS_GETITIMER) && defined(HAS_SETITIMER) */

#if defined(TIME_HIRES_CLOCK_GETTIME)

NV
clock_gettime(clock_id = CLOCK_REALTIME)
	int clock_id
    PREINIT:
	struct timespec ts;
	int status = -1;
    CODE:
#ifdef TIME_HIRES_CLOCK_GETTIME_SYSCALL
	status = syscall(SYS_clock_gettime, clock_id, &ts);
#else
	status = clock_gettime(clock_id, &ts);
#endif
	RETVAL = status == 0 ? ts.tv_sec + (NV) ts.tv_nsec / (NV) 1e9 : -1;

    OUTPUT:
	RETVAL

#else  /* if defined(TIME_HIRES_CLOCK_GETTIME) */

NV
clock_gettime(clock_id = 0)
	int clock_id
    CODE:
        croak("Time::HiRes::clock_gettime(): unimplemented in this platform");
        RETVAL = 0.0;

#endif /*  #if defined(TIME_HIRES_CLOCK_GETTIME) */

#if defined(TIME_HIRES_CLOCK_GETRES)

NV
clock_getres(clock_id = CLOCK_REALTIME)
	int clock_id
    PREINIT:
	int status = -1;
	struct timespec ts;
    CODE:
#ifdef TIME_HIRES_CLOCK_GETRES_SYSCALL
	status = syscall(SYS_clock_getres, clock_id, &ts);
#else
	status = clock_getres(clock_id, &ts);
#endif
	RETVAL = status == 0 ? ts.tv_sec + (NV) ts.tv_nsec / (NV) 1e9 : -1;

    OUTPUT:
	RETVAL

#else  /* if defined(TIME_HIRES_CLOCK_GETRES) */

NV
clock_getres(clock_id = 0)
	int clock_id
    CODE:
        croak("Time::HiRes::clock_getres(): unimplemented in this platform");
        RETVAL = 0.0;

#endif /*  #if defined(TIME_HIRES_CLOCK_GETRES) */

#if defined(TIME_HIRES_CLOCK_NANOSLEEP) && defined(TIMER_ABSTIME)

NV
clock_nanosleep(clock_id, nsec, flags = 0)
	int clock_id
	NV  nsec
	int flags
    PREINIT:
	struct timespec sleepfor, unslept;
    CODE:
	if (nsec < 0.0)
	    croak("Time::HiRes::clock_nanosleep(..., %"NVgf"): negative time not invented yet", nsec);
	sleepfor.tv_sec = (Time_t)(nsec / 1e9);
	sleepfor.tv_nsec = (long)(nsec - ((NV)sleepfor.tv_sec) * 1e9);
	if (!clock_nanosleep(clock_id, flags, &sleepfor, &unslept)) {
	    RETVAL = nsec;
	} else {
	    sleepfor.tv_sec -= unslept.tv_sec;
	    sleepfor.tv_nsec -= unslept.tv_nsec;
	    if (sleepfor.tv_nsec < 0) {
		sleepfor.tv_sec--;
		sleepfor.tv_nsec += 1000000000;
	    }
	    RETVAL = ((NV)sleepfor.tv_sec) * 1e9 + ((NV)sleepfor.tv_nsec);
	}
    OUTPUT:
	RETVAL

#else  /* if defined(TIME_HIRES_CLOCK_NANOSLEEP) && defined(TIMER_ABSTIME) */

NV
clock_nanosleep()
    CODE:
        croak("Time::HiRes::clock_nanosleep(): unimplemented in this platform");
        RETVAL = 0.0;

#endif /*  #if defined(TIME_HIRES_CLOCK_NANOSLEEP) && defined(TIMER_ABSTIME) */

#if defined(TIME_HIRES_CLOCK) && defined(CLOCKS_PER_SEC)

NV
clock()
    PREINIT:
	clock_t clocks;
    CODE:
	clocks = clock();
	RETVAL = clocks == -1 ? -1 : (NV)clocks / (NV)CLOCKS_PER_SEC;

    OUTPUT:
	RETVAL

#else  /* if defined(TIME_HIRES_CLOCK) && defined(CLOCKS_PER_SEC) */

NV
clock()
    CODE:
        croak("Time::HiRes::clock(): unimplemented in this platform");
        RETVAL = 0.0;

#endif /*  #if defined(TIME_HIRES_CLOCK) && defined(CLOCKS_PER_SEC) */

void
stat(...)
PROTOTYPE: ;$
    PPCODE:
	PUSHMARK(SP);
	XPUSHs(sv_2mortal(newSVsv(items == 1 ? ST(0) : DEFSV)));
	PUTBACK;
	ENTER;
	PL_laststatval = -1;
	(void)*(PL_ppaddr[OP_STAT])(aTHXR);
	SPAGAIN;
	LEAVE;
	if (PL_laststatval == 0) {
	  /* We assume that pp_stat() left us with 13 valid stack items,
	   * and that the timestamps are at offsets 8, 9, and 10. */
	  UV atime = SvUV(ST( 8));
	  UV mtime = SvUV(ST( 9));
	  UV ctime = SvUV(ST(10));
	  UV atime_nsec;
	  UV mtime_nsec;
	  UV ctime_nsec;
	  hrstatns(atime, mtime, ctime,
		   &atime_nsec, &mtime_nsec, &ctime_nsec);
	  if (atime_nsec)
	    ST( 8) = sv_2mortal(newSVnv(atime + 1e-9 * (NV) atime_nsec));
	  if (mtime_nsec)
	    ST( 9) = sv_2mortal(newSVnv(mtime + 1e-9 * (NV) mtime_nsec));
	  if (ctime_nsec)
	    ST(10) = sv_2mortal(newSVnv(ctime + 1e-9 * (NV) ctime_nsec));
	  XSRETURN(13);
	}
	XSRETURN(0);