Linux下的时间概念

      int main(VOID)
   {
     HEV     hevEvent1     = 0;   /* Event semaphore handle */
     HTIMER  htimerEvent1  = 0;   /* Timer handle */
     APIRET  rc            = NO_ERROR;          /* Return code */
     ULONG   ulPostCount   = 0;                 /* Semaphore post count */
     ULONG   i             = 0;                 /* A loop index */
     /*
      * Create an even semaphore that will be posted on timer interval
      */
     rc = DosCreateEventSem(NULL,            /* Unnamed semaphore */
                            &hevEvent1,          /* Handle of semaphore
       * returned
       */
                            DC_SEM_SHARED,  /* Indicate a shared semaphore */
                            FALSE);         /* Put in RESET state */
     if (rc != NO_ERROR) {
          printf("DosCreateEventSem error: return code = %u\n", rc);
          return 1;
     }
     /*
      * Start the timer setting a interval at 1 sec
      */
     rc = DosStartTimer(1000L,              /* 1 second interval */
                       (HSEM) hevEvent1,    /* Semaphore to post */
                       &htimerEvent1);      /* Timer handler (returned) */
     if (rc != NO_ERROR) {
          printf("DosStartTimer error: return code = %u\n", rc);
          return 1;
     }
     for (i = 1 ; i < 6 ; i++)
     {
        DosWaitEventSem(hevEvent1, SEM_INDEFINITE_WAIT); /* Wait indefinitely */
        DosResetEventSem(hevEvent1,          /* Reset the semaphore */
                         &ulPostCount);    /* And get count
       * (should be 1)
       */
        printf("Iteration %u: ulPostCount = %u\n", i, ulPostCount);
     }       /* for loop */
     rc = DosStopTimer(htimerEvent1);        /* Stop the timer */
     if (rc != NO_ERROR)
     {
        printf("DosStopTimer error: return code = %u\n", rc);
        return 1;
     }
     DosCloseEventSem(hevEvent1);        /* Get rid of semaphore */
     return NO_ERROR;
   }

   sem_t sem;
   /* callback to handle SIGALRM */
   void f (int signo)
   {
         /* Here you can post on a semaphore */
          sem_post(&sem);
   }
   int main ()
   {
         int i;
         int rc;
         /* Declare an itimer object to start a timer */
         struct itimerval itimer;
         /* Initialize the semaphore. */
         sem_init(&sem,0,0);
      /* timer interval is 1 sec. */
         itimer.it_interval.tv_sec = 1;
         itimer.it_interval.tv_usec = 0;
     /* Time to the next timer expiration  */
         itimer.it_value.tv_sec = 1;
         itimer.it_value.tv_usec = 0;
         /* Install a signal handler to handle SIGALRM */
         signal (SIGALRM, f);
         /* Start a timer with the  ITIMER_REAL clock */
         i = setitimer (ITIMER_REAL, &itimer, 0);
         if (i == -1)
         {
             perror ("timer st failed ...\n");
             exit (0);
         }
   for (i = 1 ; i < 6 ; i++)
   {
        rc = sem_wait(&sem);
        if (rc != 0)
        {
            perror ("sem_wait:");
            return 1;
        }
        printf("Iteration %d: \n", i);
    } /* for loop */
      /* Set the timer object value with zero, by using the macro
       * timerclear and
       * set the ITIMER_REAL by calling setitimer.
       * This essentially stops the timer.
       */
          timerclear(&itimer.it_value);
         setitimer (ITIMER_REAL, &itimer, 0);
         return 0;
   }

   /*
    * Macro to compare keywords
    * strcmp is called only when the first characters are the same
    */
   #define WordMatch(a, b) ( (*(a) == *(b)) && (strcmp(a, b) == 0) )
   int GetClockFreq(unsigned long *pulCpuFreq)
   {
     char* pcFilename = "/proc/cpuinfo";
     char pcReadLine[BUFSIZE];
     char pcKeyword[BUFSIZE];
     char pcKeyword2[BUFSIZE];
     int iDone = 0;                 /* Flag to determine end of loop */
     *pulCpuFreq = 0;
     memset(pcReadLine,0,BUFSIZE);
     memset(pcKeyword,0,BUFSIZE);
     memset(pcKeyword2,0,BUFSIZE);
     /*
      * Open the /proc/cpuinfo file
      */
     fstream fpCpuInfo(pcFilename, ios::in);
       if (fpCpuInfo)
       {
           /*
            * Read a line into the buffer
            */
           while ((fpCpuInfo.getline(pcReadLine, BUFSIZE)) && (iDone == 0))
           {
           /*
            * Instantiate istrmInput to translate input line into
            * a stream object
            */
           istrstream istrmInput(pcReadLine);
           /*
            * Get first 2 word from the input line and build the keyword
            */
     istrmInput >> pcKeyword;
           istrmInput >> pcKeyword2;
           strcat(pcKeyword, " ");
           strcat(pcKeyword, pcKeyword2);
           if (WordMatch(pcKeyword, "cpu MHz"))
           {
               /*
                * Get the Mhz value from input line by skipping
                * past the colon.
                */
               istrmInput >> pcKeyword;
               istrmInput >> pcKeyword;
               /*
                * Convert the char* to float and multiply by 1000000 to
                * get the clock in Hz
                */
               *pulCpuFreq = (unsigned long)(atof(pcKeyword) * 1000000);
                     iDone = 1;
           }
        }  /* end of while */
         fpCpuInfo.close();
     }
     return ((iDone)?0:-1);
   }

   void GetTimeStampPair( )
    {
       struct QWORD  qwStartTime, qwStopTime;
       double diff;
       Unsigned long ulTmrFreq;
       DosTmrQueryTime(&qwStartTime);
       /* perform an activity */
       diff = 0;
       DosTmrQueryTime(&qwStopTime);
       /* Calculate the difference between two times */
       diff = qwStopTime.ulLo - qwStartTime.ulLo;
       /* Query the Intel chip's resolution */
       DosTmrQueryFreq(&ulTmrFreq);
       printf ("Timer Frequency  is %ld\n Hz", ulTmrFreq);
       /* calculate the time take for the assignment operation */
       /* diff time/frequency */
       printf(" Time taken for the activity %ld\n", diff/ulTmrFreq);
    }  /* end GetTimeStampPair */

   /*
    * This function uses the user defined function GetClockFreq()
    */
   #define NANOSLEEP     10000000                     /* 10 ms */
   #define MSLEEP        NANOSLEEP/1000000
   int main (void)
   {
         unsigned long t1, t2, jitter, freq;
         double accum;
         int ret;
         struct sched_param sp;
         struct timespec ts,rem;
               /* Set the scheduling priority to the real time */
             sp.sched_priority = sched_get_priority_max(SCHED_RR);
             sched_setscheduler(getpid(), SCHED_RR, &sp);
              mlockall(MCL_FUTURE|MCL_CURRENT);
            rem.tv_sec = 0;
         ret = GetClockFreq (&freq);
         if (ret)
         {
            /* error condition */
            return  -1;
         }
         rem.tv_sec = 0;
         rem.tv_nsec = NANOSLEEP;
         t1 = get_cycles();
         do {
             ts.tv_sec = rem.tv_sec;
             ts.tv_nsec = rem.tv_nsec;
             rem.tv_nsec = 0;
             ret = nanosleep(&ts, &rem);
         } while (rem.tv_nsec != 0);
         t2 = get_cycles();
               jitter = t2 - t1;
               /* How much time elapsed. Number of ticks
  * divided by frequency of the clock
  */
          accum = (double)jitter/freq;
         return 0;
   }