00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #include "polarssl/config.h"
00027
00028 #if defined(POLARSSL_TIMING_C)
00029
00030 #include "polarssl/timing.h"
00031
00032 #if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
00033
00034 #include <windows.h>
00035 #include <winbase.h>
00036
00037 struct _hr_time
00038 {
00039 LARGE_INTEGER start;
00040 };
00041
00042 #else
00043
00044 #include <unistd.h>
00045 #include <sys/types.h>
00046 #include <sys/time.h>
00047 #include <signal.h>
00048 #include <time.h>
00049
00050 struct _hr_time
00051 {
00052 struct timeval start;
00053 };
00054
00055 #endif
00056
00057 #if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
00058 (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)
00059
00060 #define POLARSSL_HAVE_HARDCLOCK
00061
00062 unsigned long hardclock( void )
00063 {
00064 unsigned long tsc;
00065 __asm rdtsc
00066 __asm mov [tsc], eax
00067 return( tsc );
00068 }
00069 #endif
00070
00071 #if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
00072 defined(__GNUC__) && defined(__i386__)
00073
00074 #define POLARSSL_HAVE_HARDCLOCK
00075
00076 unsigned long hardclock( void )
00077 {
00078 unsigned long lo, hi;
00079 asm( "rdtsc" : "=a" (lo), "=d" (hi) );
00080 return( lo );
00081 }
00082 #endif
00083
00084 #if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
00085 defined(__GNUC__) && (defined(__amd64__) || defined(__x86_64__))
00086
00087 #define POLARSSL_HAVE_HARDCLOCK
00088
00089 unsigned long hardclock( void )
00090 {
00091 unsigned long lo, hi;
00092 asm( "rdtsc" : "=a" (lo), "=d" (hi) );
00093 return( lo | (hi << 32) );
00094 }
00095 #endif
00096
00097 #if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
00098 defined(__GNUC__) && (defined(__powerpc__) || defined(__ppc__))
00099
00100 #define POLARSSL_HAVE_HARDCLOCK
00101
00102 unsigned long hardclock( void )
00103 {
00104 unsigned long tbl, tbu0, tbu1;
00105
00106 do
00107 {
00108 asm( "mftbu %0" : "=r" (tbu0) );
00109 asm( "mftb %0" : "=r" (tbl ) );
00110 asm( "mftbu %0" : "=r" (tbu1) );
00111 }
00112 while( tbu0 != tbu1 );
00113
00114 return( tbl );
00115 }
00116 #endif
00117
00118 #if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
00119 defined(__GNUC__) && defined(__sparc64__)
00120
00121 #if defined(__OpenBSD__)
00122 #warning OpenBSD does not allow access to tick register using software version instead
00123 #else
00124 #define POLARSSL_HAVE_HARDCLOCK
00125
00126 unsigned long hardclock( void )
00127 {
00128 unsigned long tick;
00129 asm( "rdpr %%tick, %0;" : "=&r" (tick) );
00130 return( tick );
00131 }
00132 #endif
00133 #endif
00134
00135 #if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
00136 defined(__GNUC__) && defined(__sparc__) && !defined(__sparc64__)
00137
00138 #define POLARSSL_HAVE_HARDCLOCK
00139
00140 unsigned long hardclock( void )
00141 {
00142 unsigned long tick;
00143 asm( ".byte 0x83, 0x41, 0x00, 0x00" );
00144 asm( "mov %%g1, %0" : "=r" (tick) );
00145 return( tick );
00146 }
00147 #endif
00148
00149 #if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
00150 defined(__GNUC__) && defined(__alpha__)
00151
00152 #define POLARSSL_HAVE_HARDCLOCK
00153
00154 unsigned long hardclock( void )
00155 {
00156 unsigned long cc;
00157 asm( "rpcc %0" : "=r" (cc) );
00158 return( cc & 0xFFFFFFFF );
00159 }
00160 #endif
00161
00162 #if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(POLARSSL_HAVE_ASM) && \
00163 defined(__GNUC__) && defined(__ia64__)
00164
00165 #define POLARSSL_HAVE_HARDCLOCK
00166
00167 unsigned long hardclock( void )
00168 {
00169 unsigned long itc;
00170 asm( "mov %0 = ar.itc" : "=r" (itc) );
00171 return( itc );
00172 }
00173 #endif
00174
00175 #if !defined(POLARSSL_HAVE_HARDCLOCK) && defined(_MSC_VER) && \
00176 !defined(EFIX64) && !defined(EFI32)
00177
00178 #define POLARSSL_HAVE_HARDCLOCK
00179
00180 unsigned long hardclock( void )
00181 {
00182 LARGE_INTEGER offset;
00183
00184 QueryPerformanceCounter( &offset );
00185
00186 return (unsigned long)( offset.QuadPart );
00187 }
00188 #endif
00189
00190 #if !defined(POLARSSL_HAVE_HARDCLOCK)
00191
00192 #define POLARSSL_HAVE_HARDCLOCK
00193
00194 static int hardclock_init = 0;
00195 static struct timeval tv_init;
00196
00197 unsigned long hardclock( void )
00198 {
00199 struct timeval tv_cur;
00200
00201 if( hardclock_init == 0 )
00202 {
00203 gettimeofday( &tv_init, NULL );
00204 hardclock_init = 1;
00205 }
00206
00207 gettimeofday( &tv_cur, NULL );
00208 return( ( tv_cur.tv_sec - tv_init.tv_sec ) * 1000000
00209 + ( tv_cur.tv_usec - tv_init.tv_usec ) );
00210 }
00211 #endif
00212
00213 volatile int alarmed = 0;
00214
00215 #if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
00216
00217 unsigned long get_timer( struct hr_time *val, int reset )
00218 {
00219 unsigned long delta;
00220 LARGE_INTEGER offset, hfreq;
00221 struct _hr_time *t = (struct _hr_time *) val;
00222
00223 QueryPerformanceCounter( &offset );
00224 QueryPerformanceFrequency( &hfreq );
00225
00226 delta = (unsigned long)( ( 1000 *
00227 ( offset.QuadPart - t->start.QuadPart ) ) /
00228 hfreq.QuadPart );
00229
00230 if( reset )
00231 QueryPerformanceCounter( &t->start );
00232
00233 return( delta );
00234 }
00235
00236 DWORD WINAPI TimerProc( LPVOID uElapse )
00237 {
00238 Sleep( (DWORD) uElapse );
00239 alarmed = 1;
00240 return( TRUE );
00241 }
00242
00243 void set_alarm( int seconds )
00244 {
00245 DWORD ThreadId;
00246
00247 alarmed = 0;
00248 CloseHandle( CreateThread( NULL, 0, TimerProc,
00249 (LPVOID) ( seconds * 1000 ), 0, &ThreadId ) );
00250 }
00251
00252 void m_sleep( int milliseconds )
00253 {
00254 Sleep( milliseconds );
00255 }
00256
00257 #else
00258
00259 unsigned long get_timer( struct hr_time *val, int reset )
00260 {
00261 unsigned long delta;
00262 struct timeval offset;
00263 struct _hr_time *t = (struct _hr_time *) val;
00264
00265 gettimeofday( &offset, NULL );
00266
00267 delta = ( offset.tv_sec - t->start.tv_sec ) * 1000
00268 + ( offset.tv_usec - t->start.tv_usec ) / 1000;
00269
00270 if( reset )
00271 {
00272 t->start.tv_sec = offset.tv_sec;
00273 t->start.tv_usec = offset.tv_usec;
00274 }
00275
00276 return( delta );
00277 }
00278
00279 #if defined(INTEGRITY)
00280 void m_sleep( int milliseconds )
00281 {
00282 usleep( milliseconds * 1000 );
00283 }
00284
00285 #else
00286
00287 static void sighandler( int signum )
00288 {
00289 alarmed = 1;
00290 signal( signum, sighandler );
00291 }
00292
00293 void set_alarm( int seconds )
00294 {
00295 alarmed = 0;
00296 signal( SIGALRM, sighandler );
00297 alarm( seconds );
00298 }
00299
00300 void m_sleep( int milliseconds )
00301 {
00302 struct timeval tv;
00303
00304 tv.tv_sec = milliseconds / 1000;
00305 tv.tv_usec = milliseconds * 1000;
00306
00307 select( 0, NULL, NULL, NULL, &tv );
00308 }
00309 #endif
00310
00311 #endif
00312
00313 #endif