Subversion Repositories shark

Rev

Rev 536 | Blame | Compare with Previous | Last modification | View Log | RSS feed

/* Project:     OSLib
 * Description: The OS Construction Kit
 * Date:                1.6.2000
 * Idea by:             Luca Abeni & Gerardo Lamastra
 *
 * OSLib is an SO project aimed at developing a common, easy-to-use
 * low-level infrastructure for developing OS kernels and Embedded
 * Applications; it partially derives from the HARTIK project but it
 * currently is independently developed.
 *
 * OSLib is distributed under GPL License, and some of its code has
 * been derived from the Linux kernel source; also some important
 * ideas come from studying the DJGPP go32 extender.
 *
 * We acknowledge the Linux Community, Free Software Foundation,
 * D.J. Delorie and all the other developers who believe in the
 * freedom of software and ideas.
 *
 * For legalese, check out the included GPL license.
 */


/*      Inline functions for managing timespec structures.
        All timespec values are pointers!!!
        This file defines these functions:
                TIMESPEC2NANOSEC(t)
                converts a timespec value to a nanosec value, and return
                        it, no checks
                TIMESPEC2USEC(t)
                converts a timespec value to a nanosec value, and return
                it, no checks
                NULL_TIMESPEC(t)
                the timespec value is set to the Epoch (=0)
                ADDNANO2TIMESPEC(n, t)
                t = t + n
                ADDUSEC2TIMESPEC(m, t)
                t = t + m
                SUBTIMESPEC(s1, s2, d) Works well only if s1 >= s2
                d = s1 - s2
                ADDTIMESPEC(s1, s2, d)
                d = s1 + s2
                TIMESPEC_A_LT_B(a,b)
                a < b
                TIMESPEC_A_GT_B(a,b)
                a > b
                TIMESPEC_A_EQ_B(a,b)
                a == b
                TIMESPEC_A_NEQ_B(a,b)
                a != b
                TIMESPEC_ASSIGN(t1,t2)
                t1 = t2 */


#ifndef __LL_SYS_LL_TIME_H__
#define __LL_SYS_LL_TIME_H__

#include <ll/i386/defs.h>
BEGIN_DEF

#ifndef _STRUCT_TIMESPEC
#define _STRUCT_TIMESPEC

struct timespec {
        long    tv_sec;         /* Seconds */
        long    tv_nsec;        /* Nanoseconds */
};

#endif

/*
 * these macros come from the Utah Flux oskit...
 */


#define TIMESPEC2NANOSEC(t)     ((t)->tv_sec * 1000000000 + (t)->tv_nsec)
#define TIMESPEC2USEC(t)     ((t)->tv_sec * 1000000 + (t)->tv_nsec / 1000)
#define NULL_TIMESPEC(t)        ((t)->tv_sec = (t)->tv_nsec = 0)
#define ADDNANO2TIMESPEC(n, t)  ((t)->tv_nsec += (n), \
                (t)->tv_sec += (t)->tv_nsec / 1000000000, \
                (t)->tv_nsec %= 1000000000)


#define SUBTIMESPEC(s1, s2, d)                               \
        ((d)->tv_nsec = ((s1)->tv_nsec >= (s2)->tv_nsec) ?   \
         (((d)->tv_sec = (s1)->tv_sec - (s2)->tv_sec),       \
          (s1)->tv_nsec - (s2)->tv_nsec)                     \
         :                                                   \
         (((d)->tv_sec = (s1)->tv_sec - (s2)->tv_sec - 1),   \
          (1000000000 + (s1)->tv_nsec - (s2)->tv_nsec)))


/*
 * ...and these not!
 */


extern __inline__ void ADDTIMESPEC(const struct timespec *s1,
                                   const struct timespec *s2,
                                   struct timespec *d)
{
  d->tv_sec  = s1->tv_sec + s2->tv_sec;
  d->tv_nsec = s1->tv_nsec + s2->tv_nsec;

  if (d->tv_nsec < 0) {
    d->tv_sec--;
    d->tv_nsec += 1000000000;
  } else if (d->tv_nsec >= 1000000000) {
    d->tv_sec++;
    d->tv_nsec -= 1000000000;
  }
}


#define ADDUSEC2TIMESPEC(m, t)  ((t)->tv_nsec += (m%1000000)*1000,        \
                (t)->tv_sec += ((t)->tv_nsec / 1000000000) + (m/1000000), \
                (t)->tv_nsec %= 1000000000)


#define TIMESPEC_A_LT_B(a,b)                                            \
        (                                                               \
        ((a)->tv_sec <  (b)->tv_sec) ||                                 \
        ((a)->tv_sec == (b)->tv_sec && (a)->tv_nsec < (b)->tv_nsec)    \
        )


#define TIMESPEC_A_GT_B(a,b)                                            \
        (                                                               \
        ((a)->tv_sec >  (b)->tv_sec) ||                                 \
        ((a)->tv_sec == (b)->tv_sec && (a)->tv_nsec > (b)->tv_nsec)    \
        )


#define TIMESPEC_A_EQ_B(a,b)                                            \
        ((a)->tv_sec == (b)->tv_sec && (a)->tv_nsec == (b)->tv_nsec)


#define TIMESPEC_A_NEQ_B(a,b)                                            \
        ((a)->tv_sec != (b)->tv_sec || (a)->tv_nsec != (b)->tv_nsec)


#define TIMESPEC_ASSIGN(t1,t2) \
        ((t1)->tv_sec = (t2)->tv_sec, (t1)->tv_nsec = (t2)->tv_nsec)


#if 0
#define PITSPEC2TIMESPEC(a,b) \
     ((b)->tv_nsec = (((DWORD)((a)->units) * 1000) / 1197) * 1000, \
        (b)->tv_sec = ((a)->gigas * 1197) / 1000) /*, \
        (b)->tv_sec += (b)->tv_nsec / 1000000000, \
        (b)->tv_nsec %= 1000000000)     */

#else
/*#define PITSPEC2TIMESPEC(a,b) \
     ((b)->tv_nsec = (((DWORD)((a)->units) * 1000) / 1197) * 1000, \
        (b)->tv_nsec += (((a)->gigas * 1197) % 1000) * 1000000, \
        (b)->tv_sec = ((a)->gigas * 1197) / 1000 , \
        (b)->tv_sec += (b)->tv_nsec / 1000000000, \
        (b)->tv_nsec %= 1000000000)*/

#define PITSPEC2TIMESPEC(a,b) \
     ((b)->tv_nsec = (((DWORD)((a)->units) * 1000) / 1193), \
        (b)->tv_nsec += (((a)->gigas * 1193) % 1000) * 1000, \
        (b)->tv_sec = ((a)->gigas * 1193) / 1000 , \
        (b)->tv_sec += (b)->tv_nsec / 1000000, \
        (b)->tv_nsec %= 1000000, \
        (b)->tv_nsec *= 1000)

#endif

TIME ll_gettime(int mode, struct timespec *tsres);

#define TIME_PTICK      1
#define TIME_EXACT      2
#define TIME_NEW        3

END_DEF
#endif