]> git.rm.cloudns.org Git - xonotic/darkplaces.git/commitdiff
refactor timing, so that timing code is in sys_shared.c.
authordivverent <divverent@d7cf8633-e32d-0410-b094-e92efae38249>
Fri, 26 Feb 2010 15:43:58 +0000 (15:43 +0000)
committerdivverent <divverent@d7cf8633-e32d-0410-b094-e92efae38249>
Fri, 26 Feb 2010 15:43:58 +0000 (15:43 +0000)
Changes in behaviour: Win32 now prefers select() (PLEASE TEST), SDL timers can be overridden by sys_usequeryperformancecounter or sys_useclockgettime, new cvar sys_debugtime

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@10013 d7cf8633-e32d-0410-b094-e92efae38249

host.c
sys.h
sys_linux.c
sys_sdl.c
sys_shared.c
sys_win.c

diff --git a/host.c b/host.c
index 31ff4491b1e13dca7ce5ca1efcc52fa91fd5a350..c8a5c8ed301b12f747a3221a5b5db24124c35d9c 100644 (file)
--- a/host.c
+++ b/host.c
@@ -720,7 +720,7 @@ void Host_Main(void)
                if (!cls.timedemo && wait >= 1)
                {
                        double time0 = Sys_DoubleTime();
-                       if (sv_checkforpacketsduringsleep.integer)
+                       if (sv_checkforpacketsduringsleep.integer && !sys_usenoclockbutbenchmark.integer)
                                NetConn_SleepMicroseconds((int)wait);
                        else
                                Sys_Sleep((int)wait);
diff --git a/sys.h b/sys.h
index aa99f79bb5cc4da732f7d8297e5b668a8f06b1d0..5a9831a7ac5ac767fab933597c2d2fb3ea571c56 100644 (file)
--- a/sys.h
+++ b/sys.h
@@ -22,6 +22,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #ifndef SYS_H
 #define SYS_H
 
+extern cvar_t sys_usenoclockbutbenchmark;
 
 //
 // DLL management
@@ -95,5 +96,9 @@ void Sys_SendKeyEvents (void);
 
 char *Sys_GetClipboardData (void);
 
+extern qboolean sys_supportsdlgetticks;
+unsigned int Sys_SDL_GetTicks (void); // wrapper to call SDL_GetTicks
+void Sys_SDL_Delay (unsigned int milliseconds); // wrapper to call SDL_Delay
+
 #endif
 
index c274cf3b361f60855dd9bf7e6a0991ad687eb602..269d2b9c4e9d4029b1af06ef5f36878e9e30b2d0 100644 (file)
@@ -8,26 +8,12 @@
 #else
 #include <unistd.h>
 #include <fcntl.h>
-#include <sys/time.h>
 #include <time.h>
 #endif
 
 #include <signal.h>
 
 
-cvar_t sys_usenoclockbutbenchmark = {CVAR_SAVE, "sys_usenoclockbutbenchmark", "0", "don't use ANY real timing, and simulate a clock (for benchmarking); the game then runs as fast as possible. Run a QC mod with bots that does some stuff, then does a quit at the end, to benchmark a server. NEVER do this on a public server."};
-static unsigned long benchmark_time;
-
-#ifdef WIN32
-cvar_t sys_usetimegettime = {CVAR_SAVE, "sys_usetimegettime", "1", "use windows timeGetTime function (which has issues on some motherboards) for timing rather than QueryPerformanceCounter timer (which has issues on multicore/multiprocessor machines and processors which are designed to conserve power)"};
-#else
-# ifndef MACOSX
-cvar_t sys_useclockgettime = {CVAR_SAVE, "sys_useclockgettime", "0", "use POSIX clock_gettime function (which has issues if the system clock speed is far off, as it can't get fixed by NTP) for timing rather than gettimeofday (which has issues if the system time is stepped by ntpdate, or apparently on some Xen installations)"};
-# endif
-#endif
-
-
-
 // =======================================================================
 // General routines
 // =======================================================================
@@ -82,113 +68,6 @@ void Sys_PrintToTerminal(const char *text)
        //fprintf(stdout, "%s", text);
 }
 
-double Sys_DoubleTime (void)
-{
-       static int first = true;
-       static double oldtime = 0.0, curtime = 0.0;
-       double newtime;
-       if(sys_usenoclockbutbenchmark.integer)
-       {
-               benchmark_time += 1;
-               return ((double) benchmark_time) / 1e6;
-       }
-#ifdef WIN32
-       // LordHavoc: note to people modifying this code, DWORD is specifically defined as an unsigned 32bit number, therefore the 65536.0 * 65536.0 is fine.
-       if (sys_usetimegettime.integer)
-       {
-               static int firsttimegettime = true;
-               // timeGetTime
-               // platform:
-               // Windows 95/98/ME/NT/2000/XP
-               // features:
-               // reasonable accuracy (millisecond)
-               // issues:
-               // wraps around every 47 days or so (but this is non-fatal to us, odd times are rejected, only causes a one frame stutter)
-
-               // make sure the timer is high precision, otherwise different versions of windows have varying accuracy
-               if (firsttimegettime)
-               {
-                       timeBeginPeriod (1);
-                       firsttimegettime = false;
-               }
-
-               newtime = (double) timeGetTime () / 1000.0;
-       }
-       else
-       {
-               // QueryPerformanceCounter
-               // platform:
-               // Windows 95/98/ME/NT/2000/XP
-               // features:
-               // very accurate (CPU cycles)
-               // known issues:
-               // does not necessarily match realtime too well (tends to get faster and faster in win98)
-               // wraps around occasionally on some platforms (depends on CPU speed and probably other unknown factors)
-               double timescale;
-               LARGE_INTEGER PerformanceFreq;
-               LARGE_INTEGER PerformanceCount;
-
-               if (!QueryPerformanceFrequency (&PerformanceFreq))
-               {
-                       Con_Printf ("No hardware timer available\n");
-                       // fall back to timeGetTime
-                       Cvar_SetValueQuick(&sys_usetimegettime, true);
-                       return Sys_DoubleTime();
-               }
-               QueryPerformanceCounter (&PerformanceCount);
-
-               #ifdef __BORLANDC__
-               timescale = 1.0 / ((double) PerformanceFreq.u.LowPart + (double) PerformanceFreq.u.HighPart * 65536.0 * 65536.0);
-               newtime = ((double) PerformanceCount.u.LowPart + (double) PerformanceCount.u.HighPart * 65536.0 * 65536.0) * timescale;
-               #else
-               timescale = 1.0 / ((double) PerformanceFreq.LowPart + (double) PerformanceFreq.HighPart * 65536.0 * 65536.0);
-               newtime = ((double) PerformanceCount.LowPart + (double) PerformanceCount.HighPart * 65536.0 * 65536.0) * timescale;
-               #endif
-       }
-#else
-# ifndef MACOSX
-       if (sys_useclockgettime.integer)
-       {
-               struct timespec ts;
-#  ifdef SUNOS
-               clock_gettime(CLOCK_HIGHRES, &ts);
-#  else
-               clock_gettime(CLOCK_MONOTONIC, &ts);
-#  endif
-               newtime = (double) ts.tv_sec + ts.tv_nsec / 1000000000.0;
-       }
-       else
-# endif
-       {
-               struct timeval tp;
-               gettimeofday(&tp, NULL);
-               newtime = (double) tp.tv_sec + tp.tv_usec / 1000000.0;
-       }
-#endif
-
-       if (first)
-       {
-               first = false;
-               oldtime = newtime;
-       }
-
-       if (newtime < oldtime)
-       {
-               // warn if it's significant
-               if (newtime - oldtime < -0.01)
-                       Con_Printf("Sys_DoubleTime: time stepped backwards (went from %f to %f, difference %f)\n", oldtime, newtime, newtime - oldtime);
-       }
-       else if (newtime > oldtime + 1800)
-       {
-               Con_Printf("Sys_DoubleTime: time stepped forward (went from %f to %f, difference %f)\n", oldtime, newtime, newtime - oldtime);
-       }
-       else
-               curtime += newtime - oldtime;
-       oldtime = newtime;
-
-       return curtime;
-}
-
 char *Sys_ConsoleInput(void)
 {
        //if (cls.state == ca_dedicated)
@@ -252,20 +131,6 @@ char *Sys_ConsoleInput(void)
        return NULL;
 }
 
-void Sys_Sleep(int microseconds)
-{
-       if(sys_usenoclockbutbenchmark.integer)
-       {
-               benchmark_time += microseconds;
-               return;
-       }
-#ifdef WIN32
-       Sleep(microseconds / 1000);
-#else
-       usleep(microseconds);
-#endif
-}
-
 char *Sys_GetClipboardData (void)
 {
        return NULL;
@@ -275,18 +140,6 @@ void Sys_InitConsole (void)
 {
 }
 
-void Sys_Init_Commands (void)
-{
-       Cvar_RegisterVariable(&sys_usenoclockbutbenchmark);
-#ifdef WIN32
-       Cvar_RegisterVariable(&sys_usetimegettime);
-#else
-# ifndef MACOSX
-       Cvar_RegisterVariable(&sys_useclockgettime);
-# endif
-#endif
-}
-
 int main (int argc, char **argv)
 {
        signal(SIGFPE, SIG_IGN);
@@ -302,3 +155,14 @@ int main (int argc, char **argv)
 
        return 0;
 }
+
+qboolean sys_supportsdlgetticks = false;
+unsigned int Sys_SDL_GetTicks (void)
+{
+       Sys_Error("Called Sys_SDL_GetTicks on non-SDL target");
+       return 0;
+}
+void Sys_SDL_Delay (unsigned int milliseconds)
+{
+       Sys_Error("Called Sys_SDL_Delay on non-SDL target");
+}
index 4a908537cce4c72f4c56ac3efae71c0481a0c43e..d0efa8353c0c62a05fd7653370374f17ceaa17ac 100644 (file)
--- a/sys_sdl.c
+++ b/sys_sdl.c
@@ -69,37 +69,6 @@ void Sys_PrintToTerminal(const char *text)
        //fprintf(stdout, "%s", text);
 }
 
-double Sys_DoubleTime (void)
-{
-       static int first = true;
-       static double oldtime = 0.0, curtime = 0.0;
-       double newtime;
-       newtime = (double) SDL_GetTicks() / 1000.0;
-
-
-       if (first)
-       {
-               first = false;
-               oldtime = newtime;
-       }
-
-       if (newtime < oldtime)
-       {
-               // warn if it's significant
-               if (newtime - oldtime < -0.01)
-                       Con_Printf("Sys_DoubleTime: time stepped backwards (went from %f to %f, difference %f)\n", oldtime, newtime, newtime - oldtime);
-       }
-       else if (newtime > oldtime + 1800)
-       {
-               Con_Printf("Sys_DoubleTime: time stepped forward (went from %f to %f, difference %f)\n", oldtime, newtime, newtime - oldtime);
-       }
-       else
-               curtime += newtime - oldtime;
-       oldtime = newtime;
-
-       return curtime;
-}
-
 char *Sys_ConsoleInput(void)
 {
        if (cls.state == ca_dedicated)
@@ -160,11 +129,6 @@ char *Sys_ConsoleInput(void)
        return NULL;
 }
 
-void Sys_Sleep(int microseconds)
-{
-       SDL_Delay(microseconds / 1000);
-}
-
 char *Sys_GetClipboardData (void)
 {
 #ifdef WIN32
@@ -198,10 +162,6 @@ void Sys_InitConsole (void)
 {
 }
 
-void Sys_Init_Commands (void)
-{
-}
-
 int main (int argc, char *argv[])
 {
        signal(SIGFPE, SIG_IGN);
@@ -220,3 +180,13 @@ int main (int argc, char *argv[])
 
        return 0;
 }
+
+qboolean sys_supportsdlgetticks = true;
+unsigned int Sys_SDL_GetTicks (void)
+{
+       return SDL_GetTicks();
+}
+void Sys_SDL_Delay (unsigned int milliseconds)
+{
+       SDL_Delay(milliseconds);
+}
index b917e60dabc6899d535e35d4d0443f6ba829f9cf..962ccf41689cebc286fdf129955348b041b2af43 100644 (file)
@@ -2,10 +2,11 @@
 
 #define SUPPORTDLL
 
-# include <time.h>
 #ifndef WIN32
 # include <unistd.h>
 # include <fcntl.h>
+# include <sys/time.h>
+# include <time.h>
 #ifdef SUPPORTDLL
 # include <dlfcn.h>
 #endif
@@ -183,3 +184,215 @@ void* Sys_GetProcAddress (dllhandle_t handle, const char* name)
 #endif
 }
 
+#ifdef WIN32
+# define HAVE_TIMEGETTIME 1
+# define HAVE_QUERYPERFORMANCECOUNTER 1
+# define HAVE_Sleep 1
+#endif
+
+#if defined(CLOCK_MONOTONIC) || defined(CLOCK_HIRES)
+# define HAVE_CLOCKGETTIME 1
+#endif
+
+#ifndef WIN32
+// FIXME improve this check, manpage hints to DST_NONE
+# define HAVE_GETTIMEOFDAY 1
+#endif
+
+#ifdef FD_SET
+# define HAVE_SELECT 1
+#endif
+
+#ifndef WIN32
+// FIXME improve this check
+# define HAVE_USLEEP 1
+#endif
+
+cvar_t sys_debugsleep = {0, "sys_debugsleep", "0", "write requested and attained sleep times to standard output, to be used with gnuplot"};
+cvar_t sys_usenoclockbutbenchmark = {CVAR_SAVE, "sys_usenoclockbutbenchmark", "0", "don't use ANY real timing, and simulate a clock (for benchmarking); the game then runs as fast as possible. Run a QC mod with bots that does some stuff, then does a quit at the end, to benchmark a server. NEVER do this on a public server."};
+cvar_t sys_usesdlgetticks = {CVAR_SAVE, "sys_usesdlgetticks", "1", "use SDL_GetTicks() timer"};
+#if HAVE_QUERYPERFORMANCECOUNTER
+cvar_t sys_usequeryperformancecounter = {CVAR_SAVE, "sys_usequeryperformancecounter", "1", "use windows QueryPerformanceCounter timer (which has issues on multicore/multiprocessor machines and processors which are designed to conserve power) for timing rather than timeGetTime function (which has issues on some motherboards)"};
+#endif
+#if HAVE_CLOCKGETTIME
+cvar_t sys_useclockgettime = {CVAR_SAVE, "sys_useclockgettime", "0", "use POSIX clock_gettime function (which has issues if the system clock speed is far off, as it can't get fixed by NTP) for timing rather than gettimeofday (which has issues if the system time is stepped by ntpdate, or apparently on some Xen installations)"};
+#endif
+
+static unsigned long benchmark_time;
+
+void Sys_Init_Commands (void)
+{
+       Cvar_RegisterVariable(&sys_debugsleep);
+       Cvar_RegisterVariable(&sys_usenoclockbutbenchmark);
+#if HAVE_TIMEGETTIME || HAVE_QUERYPERFORMANCECOUNTER || HAVE_CLOCKGETTIME || HAVE_GETTIMEOFDAY
+       if(sys_supportsdlgetticks)
+               Cvar_RegisterVariable(&sys_usesdlgetticks);
+#endif
+#if HAVE_QUERYPERFORMANCECOUNTER
+       Cvar_RegisterVariable(&sys_usetimegettime);
+#endif
+#if HAVE_CLOCKGETTIME
+       Cvar_RegisterVariable(&sys_useclockgettime);
+#endif
+}
+
+double Sys_DoubleTime(void)
+{
+       static int first = true;
+       static double oldtime = 0.0, curtime = 0.0;
+       double newtime;
+       if(sys_usenoclockbutbenchmark.integer)
+       {
+               benchmark_time += 1;
+               return ((double) benchmark_time) / 1e6;
+       }
+
+       // first all the OPTIONAL timers
+
+#if HAVE_QUERYPERFORMANCECOUNTER
+       else if (sys_usequeryperformancecounter.integer)
+       {
+               // LordHavoc: note to people modifying this code, DWORD is specifically defined as an unsigned 32bit number, therefore the 65536.0 * 65536.0 is fine.
+               // QueryPerformanceCounter
+               // platform:
+               // Windows 95/98/ME/NT/2000/XP
+               // features:
+               // very accurate (CPU cycles)
+               // known issues:
+               // does not necessarily match realtime too well (tends to get faster and faster in win98)
+               // wraps around occasionally on some platforms (depends on CPU speed and probably other unknown factors)
+               double timescale;
+               LARGE_INTEGER PerformanceFreq;
+               LARGE_INTEGER PerformanceCount;
+
+               if (!QueryPerformanceFrequency (&PerformanceFreq))
+               {
+                       Con_Printf ("No hardware timer available\n");
+                       // fall back to timeGetTime
+                       Cvar_SetValueQuick(&sys_usetimegettime, true);
+                       return Sys_DoubleTime();
+               }
+               QueryPerformanceCounter (&PerformanceCount);
+
+               #ifdef __BORLANDC__
+               timescale = 1.0 / ((double) PerformanceFreq.u.LowPart + (double) PerformanceFreq.u.HighPart * 65536.0 * 65536.0);
+               newtime = ((double) PerformanceCount.u.LowPart + (double) PerformanceCount.u.HighPart * 65536.0 * 65536.0) * timescale;
+               #else
+               timescale = 1.0 / ((double) PerformanceFreq.LowPart + (double) PerformanceFreq.HighPart * 65536.0 * 65536.0);
+               newtime = ((double) PerformanceCount.LowPart + (double) PerformanceCount.HighPart * 65536.0 * 65536.0) * timescale;
+               #endif
+       }
+#endif
+
+#if HAVE_CLOCKGETTIME
+       else if (sys_useclockgettime.integer)
+       {
+               struct timespec ts;
+#  ifdef CLOCK_MONOTONIC
+               // linux
+               clock_gettime(CLOCK_MONOTONIC, &ts);
+#  else
+               // sunos
+               clock_gettime(CLOCK_HIGHRES, &ts);
+#  endif
+               newtime = (double) ts.tv_sec + ts.tv_nsec / 1000000000.0;
+       }
+#endif
+
+       // now all the FALLBACK timers
+       else if(sys_supportsdlgetticks && sys_usesdlgetticks.integer)
+       {
+               newtime = (double) Sys_SDL_GetTicks() / 1000.0;
+       }
+#if HAVE_TIMEGETTIME
+       else
+       {
+               static int firsttimegettime = true;
+               // timeGetTime
+               // platform:
+               // Windows 95/98/ME/NT/2000/XP
+               // features:
+               // reasonable accuracy (millisecond)
+               // issues:
+               // wraps around every 47 days or so (but this is non-fatal to us, odd times are rejected, only causes a one frame stutter)
+
+               // make sure the timer is high precision, otherwise different versions of windows have varying accuracy
+               if (firsttimegettime)
+               {
+                       timeBeginPeriod (1);
+                       firsttimegettime = false;
+               }
+
+               newtime = (double) timeGetTime () / 1000.0;
+       }
+#elif HAVE_GETTIMEOFDAY
+       else
+       {
+               struct timeval tp;
+               gettimeofday(&tp, NULL);
+               newtime = (double) tp.tv_sec + tp.tv_usec / 1000000.0;
+       }
+#else
+       // fallback for using the SDL timer if no other timer is available
+       else
+       {
+               newtime = (double) Sys_SDL_GetTicks() / 1000.0;
+               // this calls Sys_Error() if not linking against SDL
+       }
+#endif
+
+       if (first)
+       {
+               first = false;
+               oldtime = newtime;
+       }
+
+       if (newtime < oldtime)
+       {
+               // warn if it's significant
+               if (newtime - oldtime < -0.01)
+                       Con_Printf("Sys_DoubleTime: time stepped backwards (went from %f to %f, difference %f)\n", oldtime, newtime, newtime - oldtime);
+       }
+       else if (newtime > oldtime + 1800)
+       {
+               Con_Printf("Sys_DoubleTime: time stepped forward (went from %f to %f, difference %f)\n", oldtime, newtime, newtime - oldtime);
+       }
+       else
+               curtime += newtime - oldtime;
+       oldtime = newtime;
+
+       return curtime;
+}
+
+void Sys_Sleep(int microseconds)
+{
+       double t;
+       if(sys_usenoclockbutbenchmark.integer)
+       {
+               benchmark_time += microseconds;
+               return;
+       }
+       if(sys_debugsleep.integer)
+       {
+               t = Sys_DoubleTime();
+       }
+#if HAVE_SELECT
+       {
+               struct timeval tv;
+               tv.tv_sec = microseconds / 1000000;
+               tv.tv_usec = microseconds % 1000000;
+               select(0, NULL, NULL, NULL, &tv);
+       }
+#elif HAVE_USLEEP
+       usleep(microseconds);
+#elif HAVE_Sleep
+       Sleep(microseconds / 1000);
+#else
+       Sys_SDL_Delay(microseconds / 1000);
+#endif
+       if(sys_debugsleep.integer)
+       {
+               t = Sys_DoubleTime() - t;
+               printf("%d %f # debugsleep\n", microseconds, t);
+       }
+}
index d571dd2a4ba9173659d2f818ec8728140c561326..5079e6ac57f3fccbdb9da3ee1e5bfa133eb2d3e1 100644 (file)
--- a/sys_win.c
+++ b/sys_win.c
@@ -119,93 +119,6 @@ void Sys_PrintToTerminal(const char *text)
                WriteFile(houtput, text, (DWORD) strlen(text), &dummy, NULL);
 }
 
-/*
-================
-Sys_DoubleTime
-================
-*/
-double Sys_DoubleTime (void)
-{
-       static int first = true;
-       static double oldtime = 0.0, curtime = 0.0;
-       double newtime;
-       // LordHavoc: note to people modifying this code, DWORD is specifically defined as an unsigned 32bit number, therefore the 65536.0 * 65536.0 is fine.
-       if (sys_usetimegettime.integer)
-       {
-               static int firsttimegettime = true;
-               // timeGetTime
-               // platform:
-               // Windows 95/98/ME/NT/2000/XP
-               // features:
-               // reasonable accuracy (millisecond)
-               // issues:
-               // wraps around every 47 days or so (but this is non-fatal to us, odd times are rejected, only causes a one frame stutter)
-
-               // make sure the timer is high precision, otherwise different versions of windows have varying accuracy
-               if (firsttimegettime)
-               {
-                       timeBeginPeriod (1);
-                       firsttimegettime = false;
-               }
-
-               newtime = (double) timeGetTime () / 1000.0;
-       }
-       else
-       {
-               // QueryPerformanceCounter
-               // platform:
-               // Windows 95/98/ME/NT/2000/XP
-               // features:
-               // very accurate (CPU cycles)
-               // known issues:
-               // does not necessarily match realtime too well (tends to get faster and faster in win98)
-               // wraps around occasionally on some platforms (depends on CPU speed and probably other unknown factors)
-               double timescale;
-               LARGE_INTEGER PerformanceFreq;
-               LARGE_INTEGER PerformanceCount;
-
-               if (!QueryPerformanceFrequency (&PerformanceFreq))
-               {
-                       Con_Printf ("No hardware timer available\n");
-                       // fall back to timeGetTime
-                       Cvar_SetValueQuick(&sys_usetimegettime, true);
-                       return Sys_DoubleTime();
-               }
-               QueryPerformanceCounter (&PerformanceCount);
-
-               #ifdef __BORLANDC__
-               timescale = 1.0 / ((double) PerformanceFreq.u.LowPart + (double) PerformanceFreq.u.HighPart * 65536.0 * 65536.0);
-               newtime = ((double) PerformanceCount.u.LowPart + (double) PerformanceCount.u.HighPart * 65536.0 * 65536.0) * timescale;
-               #else
-               timescale = 1.0 / ((double) PerformanceFreq.LowPart + (double) PerformanceFreq.HighPart * 65536.0 * 65536.0);
-               newtime = ((double) PerformanceCount.LowPart + (double) PerformanceCount.HighPart * 65536.0 * 65536.0) * timescale;
-               #endif
-       }
-
-       if (first)
-       {
-               first = false;
-               oldtime = newtime;
-       }
-
-       if (newtime < oldtime)
-       {
-               // warn if it's significant
-               if (newtime - oldtime < -0.01)
-                       Con_Printf("Sys_DoubleTime: time stepped backwards (went from %f to %f, difference %f)\n", oldtime, newtime, newtime - oldtime);
-       }
-       else if (newtime > oldtime + 1800)
-       {
-               Con_Printf("Sys_DoubleTime: time stepped forward (went from %f to %f, difference %f)\n", oldtime, newtime, newtime - oldtime);
-       }
-       else
-               curtime += newtime - oldtime;
-       oldtime = newtime;
-
-       return curtime;
-}
-
-
 char *Sys_ConsoleInput (void)
 {
        static char text[MAX_INPUTLINE];
@@ -286,9 +199,14 @@ char *Sys_ConsoleInput (void)
        return NULL;
 }
 
+double Sys_DoubleTime (void)
+{
+       return Sys_DoubleTime_Shared();
+}
+
 void Sys_Sleep(int microseconds)
 {
-       Sleep(microseconds / 1000);
+       Sys_Sleep_Shared(microseconds);
 }
 
 char *Sys_GetClipboardData (void)
@@ -377,11 +295,6 @@ void Sys_InitConsole (void)
        S_BlockSound ();
 }
 
-void Sys_Init_Commands (void)
-{
-       Cvar_RegisterVariable(&sys_usetimegettime);
-}
-
 /*
 ==============================================================================
 
@@ -483,3 +396,13 @@ int main (int argc, const char* argv[])
 }
 #endif
 
+qboolean sys_supportsdlgetticks = false;
+unsigned int Sys_SDL_GetTicks (void)
+{
+       Sys_Error("Called Sys_SDL_GetTicks on non-SDL target");
+       return 0;
+}
+void Sys_SDL_Delay (unsigned int milliseconds)
+{
+       Sys_Error("Called Sys_SDL_Delay on non-SDL target");
+}