package/utils/px5g/src/library/timing.c

   1 /*
   2  *  Portable interface to the CPU cycle counter
   3  *
   4  *  Based on XySSL: Copyright (C) 2006-2008  Christophe Devine
   5  *
   6  *  Copyright (C) 2009  Paul Bakker <polarssl_maintainer at polarssl dot org>
   7  *
   8  *  All rights reserved.
   9  *
  10  *  Redistribution and use in source and binary forms, with or without
  11  *  modification, are permitted provided that the following conditions
  12  *  are met:
  13  *
  14  *    * Redistributions of source code must retain the above copyright
  15  *      notice, this list of conditions and the following disclaimer.
  16  *    * Redistributions in binary form must reproduce the above copyright
  17  *      notice, this list of conditions and the following disclaimer in the
  18  *      documentation and/or other materials provided with the distribution.
  19  *    * Neither the names of PolarSSL or XySSL nor the names of its contributors
  20  *      may be used to endorse or promote products derived from this software
  21  *      without specific prior written permission.
  22  *
  23  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  26  *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  27  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  28  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  29  *  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  30  *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  31  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  32  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  33  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 #include "polarssl/config.h"
  37
  38 #if defined(POLARSSL_TIMING_C)
  39
  40 #include "polarssl/timing.h"
  41
  42 #if defined(WIN32)
  43
  44 #include <windows.h>
  45 #include <winbase.h>
  46
  47 struct _hr_time
  48 {
  49     LARGE_INTEGER start;
  50 };
  51
  52 #else
  53
  54 #include <unistd.h>
  55 #include <sys/types.h>
  56 #include <sys/time.h>
  57 #include <signal.h>
  58 #include <time.h>
  59
  60 struct _hr_time
  61 {
  62     struct timeval start;
  63 };
  64
  65 #endif
  66
  67 #if (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)
  68
  69 unsigned long hardclock( void )
  70 {
  71     unsigned long tsc;
  72     __asm   rdtsc
  73     __asm   mov  [tsc], eax
  74     return( tsc );
  75 }
  76
  77 #else
  78 #if defined(__GNUC__) && defined(__i386__)
  79
  80 unsigned long hardclock( void )
  81 {
  82     unsigned long tsc;
  83     asm( "rdtsc" : "=a" (tsc) );
  84     return( tsc );
  85 }
  86
  87 #else
  88 #if defined(__GNUC__) && (defined(__amd64__) || defined(__x86_64__))
  89
  90 unsigned long hardclock( void )
  91 {
  92     unsigned long lo, hi;
  93     asm( "rdtsc" : "=a" (lo), "=d" (hi) );
  94     return( lo | (hi << 32) );
  95 }
  96
  97 #else
  98 #if defined(__GNUC__) && (defined(__powerpc__) || defined(__ppc__))
  99
 100 unsigned long hardclock( void )
 101 {
 102     unsigned long tbl, tbu0, tbu1;
 103
 104     do
 105     {
 106         asm( "mftbu %0" : "=r" (tbu0) );
 107         asm( "mftb  %0" : "=r" (tbl ) );
 108         asm( "mftbu %0" : "=r" (tbu1) );
 109     }
 110     while( tbu0 != tbu1 );
 111
 112     return( tbl );
 113 }
 114
 115 #else
 116 #if defined(__GNUC__) && defined(__sparc__)
 117
 118 unsigned long hardclock( void )
 119 {
 120     unsigned long tick;
 121     asm( ".byte 0x83, 0x41, 0x00, 0x00" );
 122     asm( "mov   %%g1, %0" : "=r" (tick) );
 123     return( tick );
 124 }
 125
 126 #else
 127 #if defined(__GNUC__) && defined(__alpha__)
 128
 129 unsigned long hardclock( void )
 130 {
 131     unsigned long cc;
 132     asm( "rpcc %0" : "=r" (cc) );
 133     return( cc & 0xFFFFFFFF );
 134 }
 135
 136 #else
 137 #if defined(__GNUC__) && defined(__ia64__)
 138
 139 unsigned long hardclock( void )
 140 {
 141     unsigned long itc;
 142     asm( "mov %0 = ar.itc" : "=r" (itc) );
 143     return( itc );
 144 }
 145
 146 #else
 147
 148 static int hardclock_init = 0;
 149 static struct timeval tv_init;
 150
 151 unsigned long hardclock( void )
 152 {
 153     struct timeval tv_cur;
 154
 155     if( hardclock_init == 0 )
 156     {
 157         gettimeofday( &tv_init, NULL );
 158         hardclock_init = 1;
 159     }
 160
 161     gettimeofday( &tv_cur, NULL );
 162     return( ( tv_cur.tv_sec  - tv_init.tv_sec  ) * 1000000
 163           + ( tv_cur.tv_usec - tv_init.tv_usec ) );
 164 }
 165
 166 #endif /* generic */
 167 #endif /* IA-64   */
 168 #endif /* Alpha   */
 169 #endif /* SPARC8  */
 170 #endif /* PowerPC */
 171 #endif /* AMD64   */
 172 #endif /* i586+   */
 173
 174 int alarmed = 0;
 175
 176 #if defined(WIN32)
 177
 178 unsigned long get_timer( struct hr_time *val, int reset )
 179 {
 180     unsigned long delta;
 181     LARGE_INTEGER offset, hfreq;
 182     struct _hr_time *t = (struct _hr_time *) val;
 183
 184     QueryPerformanceCounter(  &offset );
 185     QueryPerformanceFrequency( &hfreq );
 186
 187     delta = (unsigned long)( ( 1000 *
 188         ( offset.QuadPart - t->start.QuadPart ) ) /
 189            hfreq.QuadPart );
 190
 191     if( reset )
 192         QueryPerformanceCounter( &t->start );
 193
 194     return( delta );
 195 }
 196
 197 DWORD WINAPI TimerProc( LPVOID uElapse )
 198 {
 199     Sleep( (DWORD) uElapse );
 200     alarmed = 1;
 201     return( TRUE );
 202 }
 203
 204 void set_alarm( int seconds )
 205 {
 206     DWORD ThreadId;
 207
 208     alarmed = 0;
 209     CloseHandle( CreateThread( NULL, 0, TimerProc,
 210         (LPVOID) ( seconds * 1000 ), 0, &ThreadId ) );
 211 }
 212
 213 void m_sleep( int milliseconds )
 214 {
 215     Sleep( milliseconds );
 216 }
 217
 218 #else
 219
 220 unsigned long get_timer( struct hr_time *val, int reset )
 221 {
 222     unsigned long delta;
 223     struct timeval offset;
 224     struct _hr_time *t = (struct _hr_time *) val;
 225
 226     gettimeofday( &offset, NULL );
 227
 228     delta = ( offset.tv_sec  - t->start.tv_sec  ) * 1000
 229           + ( offset.tv_usec - t->start.tv_usec ) / 1000;
 230
 231     if( reset )
 232     {
 233         t->start.tv_sec  = offset.tv_sec;
 234         t->start.tv_usec = offset.tv_usec;
 235     }
 236
 237     return( delta );
 238 }
 239
 240 static void sighandler( int signum )
 241 {
 242     alarmed = 1;
 243     signal( signum, sighandler );
 244 }
 245
 246 void set_alarm( int seconds )
 247 {
 248     alarmed = 0;
 249     signal( SIGALRM, sighandler );
 250     alarm( seconds );
 251 }
 252
 253 void m_sleep( int milliseconds )
 254 {
 255     struct timeval tv;
 256
 257     tv.tv_sec  = milliseconds / 1000;
 258     tv.tv_usec = milliseconds * 1000;
 259
 260     select( 0, NULL, NULL, NULL, &tv );
 261 }
 262
 263 #endif
 264
 265 #endif