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 "tropicssl/config.h"
  37
  38 #if defined(TROPICSSL_TIMING_C)
  39
  40 #include "tropicssl/timing.h"
  41
  42 #if defined(WIN32)
  43
  44 #include <windows.h>
  45 #include <winbase.h>
  46
  47 struct _hr_time {
  48         LARGE_INTEGER start;
  49 };
  50
  51 #else
  52
  53 #include <unistd.h>
  54 #include <sys/types.h>
  55 #include <sys/time.h>
  56 #include <signal.h>
  57 #include <time.h>
  58
  59 struct _hr_time {
  60         struct timeval start;
  61 };
  62
  63 #endif
  64
  65 #if (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)
  66
  67 unsigned long hardclock(void)
  68 {
  69         unsigned long tsc;
  70         __asm rdtsc __asm mov[tsc], eax return (tsc);
  71 }
  72
  73 #else
  74 #if defined(__GNUC__) && defined(__i386__)
  75
  76 unsigned long hardclock(void)
  77 {
  78         unsigned long tsc;
  79 asm("rdtsc":"=a"(tsc));
  80         return (tsc);
  81 }
  82
  83 #else
  84 #if defined(__GNUC__) && (defined(__amd64__) || defined(__x86_64__))
  85
  86 unsigned long hardclock(void)
  87 {
  88         unsigned long lo, hi;
  89 asm("rdtsc":"=a"(lo), "=d"(hi));
  90         return (lo | (hi << 32));
  91 }
  92
  93 #else
  94 #if defined(__GNUC__) && (defined(__powerpc__) || defined(__ppc__))
  95
  96 unsigned long hardclock(void)
  97 {
  98         unsigned long tbl, tbu0, tbu1;
  99
 100         do {
 101 asm("mftbu %0":"=r"(tbu0));
 102 asm("mftb       %0":"=r"(tbl));
 103 asm("mftbu %0":"=r"(tbu1));
 104         } while (tbu0 != tbu1);
 105
 106         return (tbl);
 107 }
 108
 109 #else
 110 #if defined(__GNUC__) && defined(__sparc__)
 111
 112 unsigned long hardclock(void)
 113 {
 114         unsigned long tick;
 115         asm(".byte 0x83, 0x41, 0x00, 0x00");
 116 asm("mov        %%g1, %0":"=r"(tick));
 117         return (tick);
 118 }
 119
 120 #else
 121 #if defined(__GNUC__) && defined(__alpha__)
 122
 123 unsigned long hardclock(void)
 124 {
 125         unsigned long cc;
 126 asm("rpcc %0":"=r"(cc));
 127         return (cc & 0xFFFFFFFF);
 128 }
 129
 130 #else
 131 #if defined(__GNUC__) && defined(__ia64__)
 132
 133 unsigned long hardclock(void)
 134 {
 135         unsigned long itc;
 136 asm("mov %0 = ar.itc":"=r"(itc));
 137         return (itc);
 138 }
 139
 140 #else
 141
 142 static int hardclock_init = 0;
 143 static struct timeval tv_init;
 144
 145 unsigned long hardclock(void)
 146 {
 147         struct timeval tv_cur;
 148
 149         if (hardclock_init == 0) {
 150                 gettimeofday(&tv_init, NULL);
 151                 hardclock_init = 1;
 152         }
 153
 154         gettimeofday(&tv_cur, NULL);
 155         return ((tv_cur.tv_sec - tv_init.tv_sec) * 1000000
 156                 + (tv_cur.tv_usec - tv_init.tv_usec));
 157 }
 158
 159 #endif /* generic */
 160 #endif /* IA-64   */
 161 #endif /* Alpha   */
 162 #endif /* SPARC8  */
 163 #endif /* PowerPC */
 164 #endif /* AMD64   */
 165 #endif /* i586+   */
 166
 167 volatile int alarmed = 0;
 168
 169 #if defined(WIN32)
 170
 171 unsigned long get_timer(struct hr_time *val, int reset)
 172 {
 173         unsigned long delta;
 174         LARGE_INTEGER offset, hfreq;
 175         struct _hr_time *t = (struct _hr_time *)val;
 176
 177         QueryPerformanceCounter(&offset);
 178         QueryPerformanceFrequency(&hfreq);
 179
 180         delta = (unsigned long)((1000 *
 181                                  (offset.QuadPart - t->start.QuadPart)) /
 182                                 hfreq.QuadPart);
 183
 184         if (reset)
 185                 QueryPerformanceCounter(&t->start);
 186
 187         return (delta);
 188 }
 189
 190 DWORD WINAPI TimerProc(LPVOID uElapse)
 191 {
 192         Sleep((DWORD) uElapse);
 193         alarmed = 1;
 194         return (TRUE);
 195 }
 196
 197 void set_alarm(int seconds)
 198 {
 199         DWORD ThreadId;
 200
 201         alarmed = 0;
 202         CloseHandle(CreateThread(NULL, 0, TimerProc,
 203                                  (LPVOID) (seconds * 1000), 0, &ThreadId));
 204 }
 205
 206 void m_sleep(int milliseconds)
 207 {
 208         Sleep(milliseconds);
 209 }
 210
 211 #else
 212
 213 unsigned long get_timer(struct hr_time *val, int reset)
 214 {
 215         unsigned long delta;
 216         struct timeval offset;
 217         struct _hr_time *t = (struct _hr_time *)val;
 218
 219         gettimeofday(&offset, NULL);
 220
 221         delta = (offset.tv_sec - t->start.tv_sec) * 1000
 222             + (offset.tv_usec - t->start.tv_usec) / 1000;
 223
 224         if (reset) {
 225                 t->start.tv_sec = offset.tv_sec;
 226                 t->start.tv_usec = offset.tv_usec;
 227         }
 228
 229         return (delta);
 230 }
 231
 232 static void sighandler(int signum)
 233 {
 234         alarmed = 1;
 235         signal(signum, sighandler);
 236 }
 237
 238 void set_alarm(int seconds)
 239 {
 240         alarmed = 0;
 241         signal(SIGALRM, sighandler);
 242         alarm(seconds);
 243 }
 244
 245 void m_sleep(int milliseconds)
 246 {
 247         struct timeval tv;
 248
 249         tv.tv_sec = milliseconds / 1000;
 250         tv.tv_usec = milliseconds * 1000;
 251
 252         select(0, NULL, NULL, NULL, &tv);
 253 }
 254
 255 #endif
 256
 257 #endif