X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=sys_shared.c;h=39c9bf8bf4e1507d37a0d59b831e078dae5c63a9;hb=HEAD;hp=d06c88499b1cc5db5a05f5c8d6026a5afc4d8777;hpb=710d4ddf4df479bf2c87b8fbc31524aec6c3cd80;p=xonotic%2Fdarkplaces.git diff --git a/sys_shared.c b/sys_shared.c index d06c8849..b9a353de 100644 --- a/sys_shared.c +++ b/sys_shared.c @@ -41,18 +41,21 @@ sys_t sys; -static char sys_timestring[128]; -char *Sys_TimeString(const char *timeformat) + +size_t Sys_TimeString(char buf[], size_t bufsize, const char *timeformat) { time_t mytime = time(NULL); + size_t strlen; #if _MSC_VER >= 1400 struct tm mytm; localtime_s(&mytm, &mytime); - strftime(sys_timestring, sizeof(sys_timestring), timeformat, &mytm); + strlen = strftime(buf, bufsize, timeformat, &mytm); #else - strftime(sys_timestring, sizeof(sys_timestring), timeformat, localtime(&mytime)); + strlen = strftime(buf, bufsize, timeformat, localtime(&mytime)); #endif - return sys_timestring; + if (!strlen) // means the array contents are undefined (but it's not always an error) + buf[0] = '\0'; // better fix it + return strlen; } @@ -268,42 +271,42 @@ void* Sys_GetProcAddress (dllhandle_t handle, const char* name) #endif } + + #ifdef WIN32 # define HAVE_TIMEGETTIME 1 # define HAVE_QUERYPERFORMANCECOUNTER 1 +# define HAVE_WIN32_USLEEP 1 # define HAVE_Sleep 1 -#endif - -#ifndef WIN32 -#if defined(CLOCK_MONOTONIC) || defined(CLOCK_HIRES) -# define HAVE_CLOCKGETTIME 1 -#endif -// FIXME improve this check, manpage hints to DST_NONE -# define HAVE_GETTIMEOFDAY 1 +#else +# if defined(CLOCK_MONOTONIC) || defined(CLOCK_HIRES) +# define HAVE_CLOCKGETTIME 1 +# endif +# if _POSIX_VERSION >= 200112L +// MacOS advertises POSIX support but doesn't implement clock_nanosleep(). +// POSIX deprecated and removed usleep() so select() seems like a safer choice. +# if defined(MACOSX) +# define HAVE_SELECT_POSIX 1 +# else +# define HAVE_CLOCK_NANOSLEEP 1 +# endif +# endif #endif #ifdef FD_SET # define HAVE_SELECT 1 #endif -#ifndef WIN32 -// FIXME improve this check -# define HAVE_USLEEP 1 -#endif - // these are referenced elsewhere cvar_t sys_usenoclockbutbenchmark = {CF_SHARED, "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_libdir = {CF_READONLY | CF_SHARED, "sys_libdir", "", "Default engine library directory"}; // these are not static cvar_t sys_debugsleep = {CF_SHARED, "sys_debugsleep", "0", "write requested and attained sleep times to standard output, to be used with gnuplot"}; -static cvar_t sys_usesdlgetticks = {CF_SHARED, "sys_usesdlgetticks", "0", "use SDL_GetTicks() timer (less accurate, for debugging)"}; -static cvar_t sys_usesdldelay = {CF_SHARED, "sys_usesdldelay", "0", "use SDL_Delay() (less accurate, for debugging)"}; +static cvar_t sys_usesdlgetticks = {CF_SHARED, "sys_usesdlgetticks", "0", "use SDL_GetTicks() timer (low precision, for debugging)"}; +static cvar_t sys_usesdldelay = {CF_SHARED, "sys_usesdldelay", "0", "use SDL_Delay() (low precision, for debugging)"}; #if HAVE_QUERYPERFORMANCECOUNTER -static cvar_t sys_usequeryperformancecounter = {CF_SHARED | CF_ARCHIVE, "sys_usequeryperformancecounter", "0", "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 -static cvar_t sys_useclockgettime = {CF_SHARED | CF_ARCHIVE, "sys_useclockgettime", "1", "use POSIX clock_gettime function (not adjusted by NTP on some older Linux kernels) for timing rather than gettimeofday (which has issues if the system time is stepped by ntpdate, or apparently on some Xen installations)"}; +static cvar_t sys_usequeryperformancecounter = {CF_SHARED | CF_ARCHIVE, "sys_usequeryperformancecounter", "1", "use windows QueryPerformanceCounter timer (which has issues on systems lacking constant-rate TSCs synchronised across all cores, such as ancient PCs or VMs) for timing rather than timeGetTime function (which is low precision and had issues on some old motherboards)"}; #endif static cvar_t sys_stdout = {CF_SHARED, "sys_stdout", "1", "0: nothing is written to stdout (-nostdout cmdline option sets this), 1: normal messages are written to stdout, 2: normal messages are written to stderr (-stderr cmdline option sets this)"}; @@ -352,7 +355,7 @@ void Sys_Init_Commands (void) Cvar_RegisterVariable(&sys_debugsleep); Cvar_RegisterVariable(&sys_usenoclockbutbenchmark); Cvar_RegisterVariable(&sys_libdir); -#if HAVE_TIMEGETTIME || HAVE_QUERYPERFORMANCECOUNTER || HAVE_CLOCKGETTIME || HAVE_GETTIMEOFDAY +#if HAVE_TIMEGETTIME || HAVE_QUERYPERFORMANCECOUNTER || HAVE_CLOCKGETTIME if(sys_supportsdlgetticks) { Cvar_RegisterVariable(&sys_usesdlgetticks); @@ -362,9 +365,7 @@ void Sys_Init_Commands (void) #if HAVE_QUERYPERFORMANCECOUNTER Cvar_RegisterVariable(&sys_usequeryperformancecounter); #endif -#if HAVE_CLOCKGETTIME - Cvar_RegisterVariable(&sys_useclockgettime); -#endif + Cvar_RegisterVariable(&sys_stdout); Cvar_RegisterCallback(&sys_stdout, Sys_UpdateOutFD_c); #ifndef WIN32 @@ -372,6 +373,47 @@ void Sys_Init_Commands (void) #endif } +#ifdef WIN32 +static LARGE_INTEGER PerformanceFreq; +/// Windows default timer resolution is only 15.625ms, +/// this affects (at least) timeGetTime() and all forms of sleeping. +static void Sys_SetTimerResolution(void) +{ + NTSTATUS(NTAPI *qNtQueryTimerResolution)(OUT PULONG MinRes, OUT PULONG MaxRes, OUT PULONG CurrentRes); + NTSTATUS(NTAPI *qNtSetTimerResolution)(IN ULONG DesiredRes, IN BOOLEAN SetRes, OUT PULONG ActualRes); + const char* ntdll_names [] = + { + "ntdll.dll", + NULL + }; + dllfunction_t ntdll_funcs[] = + { + {"NtQueryTimerResolution", (void **) &qNtQueryTimerResolution}, + {"NtSetTimerResolution", (void **) &qNtSetTimerResolution}, + {NULL, NULL} + }; + dllhandle_t ntdll; + unsigned long WorstRes, BestRes, CurrentRes; + + timeBeginPeriod(1); // 1ms, documented + + // the best Windows can manage (typically 0.5ms) + // http://undocumented.ntinternals.net/index.html?page=UserMode%2FUndocumented%20Functions%2FTime%2FNtSetTimerResolution.html + if (Sys_LoadDependency(ntdll_names, &ntdll, ntdll_funcs)) + { + qNtQueryTimerResolution(&WorstRes, &BestRes, &CurrentRes); // no pointers may be NULL + if (CurrentRes > BestRes) + qNtSetTimerResolution(BestRes, true, &CurrentRes); + + Sys_FreeLibrary(&ntdll); + } + + // Microsoft says the freq is fixed at boot and consistent across all processors + // and that it need only be queried once and cached. + QueryPerformanceFrequency (&PerformanceFreq); +} +#endif // WIN32 + double Sys_DirtyTime(void) { // first all the OPTIONAL timers @@ -385,28 +427,29 @@ double Sys_DirtyTime(void) Sys_Error("sys_usenoclockbutbenchmark cannot run any longer, sorry"); return benchmark_time * 0.000001; } + + if(sys_supportsdlgetticks && sys_usesdlgetticks.integer) + return (double) Sys_SDL_GetTicks() / 1000.0; + #if HAVE_QUERYPERFORMANCECOUNTER if (sys_usequeryperformancecounter.integer) { - // LadyHavoc: 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) + // + very accurate (constant-rate TSCs on modern systems) // 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; + // - 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) + // - higher access latency on Vista + // Microsoft says on Win 7 or later, latency and overhead are very low, synchronisation is excellent. LARGE_INTEGER PerformanceCount; - if (QueryPerformanceFrequency (&PerformanceFreq)) + if (PerformanceFreq.QuadPart) { QueryPerformanceCounter (&PerformanceCount); - - timescale = 1.0 / ((double) PerformanceFreq.LowPart + (double) PerformanceFreq.HighPart * 65536.0 * 65536.0); - return ((double) PerformanceCount.LowPart + (double) PerformanceCount.HighPart * 65536.0 * 65536.0) * timescale; + return (double)PerformanceCount.QuadPart * (1.0 / (double)PerformanceFreq.QuadPart); } else { @@ -418,11 +461,13 @@ double Sys_DirtyTime(void) #endif #if HAVE_CLOCKGETTIME - if (sys_useclockgettime.integer) { struct timespec ts; -# ifdef CLOCK_MONOTONIC - // linux +# ifdef CLOCK_MONOTONIC_RAW + // Linux-specific, SDL_GetPerformanceCounter() uses it + clock_gettime(CLOCK_MONOTONIC_RAW, &ts); +# elif defined(CLOCK_MONOTONIC) + // POSIX clock_gettime(CLOCK_MONOTONIC, &ts); # else // sunos @@ -433,17 +478,8 @@ double Sys_DirtyTime(void) #endif // now all the FALLBACK timers - if(sys_supportsdlgetticks && sys_usesdlgetticks.integer) - return (double) Sys_SDL_GetTicks() / 1000.0; -#if HAVE_GETTIMEOFDAY - { - struct timeval tp; - gettimeofday(&tp, NULL); - return (double) tp.tv_sec + tp.tv_usec / 1000000.0; - } -#elif HAVE_TIMEGETTIME +#if HAVE_TIMEGETTIME { - static int firsttimegettime = true; // timeGetTime // platform: // Windows 95/98/ME/NT/2000/XP @@ -451,14 +487,7 @@ double Sys_DirtyTime(void) // 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; - } - + // requires Sys_SetTimerResolution() return (double) timeGetTime() / 1000.0; } #else @@ -468,45 +497,39 @@ double Sys_DirtyTime(void) #endif } -extern cvar_t host_maxwait; double Sys_Sleep(double time) { double dt; - uint32_t microseconds; - - // convert to microseconds - time *= 1000000.0; - - if(host_maxwait.value <= 0) - time = min(time, 1000000.0); - else - time = min(time, host_maxwait.value * 1000.0); + uint32_t msec, usec, nsec; - if (time < 1 || host.restless) + if (time < 1.0/1000000.0 || host.restless) return 0; // not sleeping this frame - - microseconds = time; // post-validation to prevent overflow + if (time >= 1) + time = 0.999999; // simpler, also ensures values are in range for all platform APIs + msec = time * 1000; + usec = time * 1000000; + nsec = time * 1000000000; if(sys_usenoclockbutbenchmark.integer) { double old_benchmark_time = benchmark_time; - benchmark_time += microseconds; + benchmark_time += usec; if(benchmark_time == old_benchmark_time) Sys_Error("sys_usenoclockbutbenchmark cannot run any longer, sorry"); return 0; } if(sys_debugsleep.integer) - Con_Printf("sys_debugsleep: requesting %u ", microseconds); + Con_Printf("sys_debugsleep: requested %u, ", usec); dt = Sys_DirtyTime(); // less important on newer libcurl so no need to disturb dedicated servers - if (cls.state != ca_dedicated && Curl_Select(microseconds)) + if (cls.state != ca_dedicated && Curl_Select(msec)) { // a transfer is ready or we finished sleeping } else if(sys_supportsdlgetticks && sys_usesdldelay.integer) - Sys_SDL_Delay(microseconds / 1000); + Sys_SDL_Delay(msec); #if HAVE_SELECT else if (cls.state == ca_dedicated && sv_checkforpacketsduringsleep.integer) { @@ -529,27 +552,53 @@ double Sys_Sleep(double time) #endif } } - tv.tv_sec = microseconds / 1000000; - tv.tv_usec = microseconds % 1000000; + tv.tv_sec = 0; + tv.tv_usec = usec; // on Win32, select() cannot be used with all three FD list args being NULL according to MSDN // (so much for POSIX...), not with an empty fd_set either. select(lastfd + 1, &fdreadset, NULL, NULL, &tv); } #endif -#if HAVE_USLEEP +#if HAVE_CLOCK_NANOSLEEP + else + { + struct timespec ts; + ts.tv_sec = 0; + ts.tv_nsec = nsec; + clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, NULL); + } +#elif HAVE_SELECT_POSIX else - usleep(microseconds); + { + struct timeval tv; + tv.tv_sec = 0; + tv.tv_usec = usec; + select(0, NULL, NULL, NULL, &tv); + } +#elif HAVE_WIN32_USLEEP // Windows XP/2003 minimum + else + { + HANDLE timer; + LARGE_INTEGER sleeptime; + + // takes 100ns units, negative indicates relative time + sleeptime.QuadPart = -((int64_t)nsec / 100); + timer = CreateWaitableTimer(NULL, true, NULL); + SetWaitableTimer(timer, &sleeptime, 0, NULL, NULL, 0); + WaitForSingleObject(timer, INFINITE); + CloseHandle(timer); + } #elif HAVE_Sleep else - Sleep(microseconds / 1000); + Sleep(msec); #else else - Sys_SDL_Delay(microseconds / 1000); + Sys_SDL_Delay(msec); #endif dt = Sys_DirtyTime() - dt; if(sys_debugsleep.integer) - Con_Printf(" got %u oversleep %d\n", (unsigned int)(dt * 1000000), (unsigned int)(dt * 1000000) - microseconds); + Con_Printf("got %u, oversleep %d\n", (uint32_t)(dt * 1000000), (uint32_t)(dt * 1000000) - usec); return (dt < 0 || dt >= 1800) ? 0 : dt; } @@ -583,12 +632,13 @@ void Sys_Print(const char *text, size_t textlen) #else #define write _write #endif - while(*text) + while(*text && textlen) { fs_offset_t written = (fs_offset_t)write(sys.outfd, text, textlen); if(written <= 0) break; // sorry, I cannot do anything about this error - without an output text += written; + textlen -= written; } #ifndef WIN32 if (sys_stdout_blocks.integer) @@ -964,16 +1014,16 @@ static void Sys_HandleCrash(int sig) sys.outfd = fileno(stderr); // not async-signal-safe :( #ifndef WIN32 fcntl(sys.outfd, F_SETFL, fcntl(sys.outfd, F_GETFL, 0) & ~O_NONBLOCK); - Sys_Print("\n\n\e[1;37;41m Engine Crash: ", 30); + Sys_Print("\n\n\x1B[1;37;41m Engine Crash: ", 30); Sys_Print(sigdesc, strlen(sigdesc)); - Sys_Print(" \e[m\n", 8); + Sys_Print(" \x1B[m\n", 8); #if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1 // the first two addresses will be in this function and in signal() in libc backtrace_symbols_fd(stackframes + 2, framecount - 2, sys.outfd); #endif - Sys_Print("\e[1m", 4); + Sys_Print("\x1B[1m", 4); Sys_Print(engineversion, strlen(engineversion)); - Sys_Print("\e[m\n", 4); + Sys_Print("\x1B[m\n", 4); #else // Windows console doesn't support colours Sys_Print("\n\nEngine Crash: ", 16); Sys_Print(sigdesc, strlen(sigdesc)); @@ -1055,7 +1105,77 @@ static void Sys_InitSignals(void) #endif } -int main (int argc, char **argv) +// Cloudwalk: Most overpowered function declaration... +static inline double Sys_UpdateTime (double newtime, double oldtime) +{ + double time = newtime - oldtime; + + if (time < 0) + { + // warn if it's significant + if (time < -0.01) + Con_Printf(CON_WARN "Host_UpdateTime: time stepped backwards (went from %f to %f, difference %f)\n", oldtime, newtime, time); + time = 0; + } + else if (time >= 1800) + { + Con_Printf(CON_WARN "Host_UpdateTime: time stepped forward (went from %f to %f, difference %f)\n", oldtime, newtime, time); + time = 0; + } + + return time; +} + +#ifdef __EMSCRIPTEN__ + #include +#endif +/// JS+WebGL doesn't support a main loop, only a function called to run a frame. +static void Sys_Frame(void) +{ + double time, newtime, sleeptime; +#ifdef __EMSCRIPTEN__ + static double sleepstarttime = 0; + host.sleeptime = Sys_DirtyTime() - sleepstarttime; +#endif + + if (setjmp(host.abortframe)) // Something bad happened, or the server disconnected + host.state = host_active; // In case we were loading + + if (host.state >= host_shutdown) // see Sys_HandleCrash() comments + { +#ifdef __EMSCRIPTEN__ + emscripten_cancel_main_loop(); +#endif +#ifdef __ANDROID__ + Sys_AllowProfiling(false); +#endif + Host_Shutdown(); + exit(0); + } + + newtime = Sys_DirtyTime(); + host.realtime += time = Sys_UpdateTime(newtime, host.dirtytime); + host.dirtytime = newtime; + + sleeptime = Host_Frame(time); + sleeptime -= Sys_DirtyTime() - host.dirtytime; // execution time + +#ifdef __EMSCRIPTEN__ + // This platform doesn't support a main loop... it will sleep when Sys_Frame() returns. + // Not using emscripten_sleep() via Sys_Sleep() because it would cause two sleeps per frame. + if (!vid_vsync.integer) // see VID_SetVsync_c() + emscripten_set_main_loop_timing(EM_TIMING_SETTIMEOUT, host.restless ? 0 : sleeptime * 1000.0); + sleepstarttime = Sys_DirtyTime(); +#else + host.sleeptime = Sys_Sleep(sleeptime); +#endif +} + +/** main() but renamed so we can wrap it in sys_sdl.c and sys_null.c + * to avoid needing to include SDL.h in this file (would make the dedicated server require SDL). + * SDL builds need SDL.h in the file where main() is defined because SDL renames and wraps main(). + */ +int Sys_Main(int argc, char *argv[]) { sys.argc = argc; sys.argv = (const char **)argv; @@ -1086,18 +1206,17 @@ int main (int argc, char **argv) Sys_InitSignals(); - Host_Main(); - -#ifdef __ANDROID__ - Sys_AllowProfiling(false); +#ifdef WIN32 + Sys_SetTimerResolution(); #endif -#ifndef WIN32 - fcntl(fileno(stdout), F_SETFL, fcntl(fileno(stdout), F_GETFL, 0) & ~O_NONBLOCK); - fcntl(fileno(stderr), F_SETFL, fcntl(fileno(stderr), F_GETFL, 0) & ~O_NONBLOCK); + Host_Init(); +#ifdef __EMSCRIPTEN__ + emscripten_set_main_loop(Sys_Frame, 0, true); // doesn't return +#else + while(true) + Sys_Frame(); #endif - fflush(stdout); - fflush(stderr); return 0; }