2 # ifndef DONT_USE_SETDLLDIRECTORY
3 # define _WIN32_WINNT 0x0502
15 # include <mmsystem.h> // timeGetTime
16 # include <time.h> // localtime
18 #pragma comment(lib, "winmm.lib")
22 # include <sys/sysctl.h>
26 # include <sys/time.h>
33 static char sys_timestring[128];
34 char *Sys_TimeString(const char *timeformat)
36 time_t mytime = time(NULL);
39 localtime_s(&mytm, &mytime);
40 strftime(sys_timestring, sizeof(sys_timestring), timeformat, &mytm);
42 strftime(sys_timestring, sizeof(sys_timestring), timeformat, localtime(&mytime));
44 return sys_timestring;
48 void Sys_Quit (int returnvalue)
50 // Unlock mutexes because the quit command may jump directly here, causing a deadlock
51 if ((cmd_client)->cbuf->lock)
52 Cbuf_Unlock((cmd_client)->cbuf);
53 if ((cmd_server)->cbuf->lock)
54 Cbuf_Unlock((cmd_server)->cbuf);
55 SV_UnlockThreadMutex();
56 TaskQueue_Frame(true);
58 if (Sys_CheckParm("-profilegameonly"))
59 Sys_AllowProfiling(false);
60 host.state = host_shutdown;
68 void Sys_AllowProfiling(qbool enable)
72 extern void monstartup(const char *libname);
73 extern void moncleanup(void);
75 monstartup("libmain.so");
79 #elif (defined(__linux__) && (defined(__GLIBC__) || defined(__GNU_LIBRARY__))) || defined(__FreeBSD__)
80 extern int moncontrol(int);
87 ===============================================================================
91 ===============================================================================
94 static qbool Sys_LoadDependencyFunctions(dllhandle_t dllhandle, const dllfunction_t *fcts, qbool complain, qbool has_next)
96 const dllfunction_t *func;
99 for (func = fcts; func && func->name != NULL; func++)
100 if (!(*func->funcvariable = (void *) Sys_GetProcAddress (dllhandle, func->name)))
104 Con_DPrintf (" - missing function \"%s\" - broken library!", func->name);
106 Con_DPrintf("\nContinuing with");
113 for (func = fcts; func && func->name != NULL; func++)
114 *func->funcvariable = NULL;
119 qbool Sys_LoadSelf(dllhandle_t *handle)
121 dllhandle_t dllhandle = 0;
126 dllhandle = LoadLibrary (NULL);
128 dllhandle = dlopen (NULL, RTLD_NOW | RTLD_GLOBAL);
134 qbool Sys_LoadDependency (const char** dllnames, dllhandle_t* handle, const dllfunction_t *fcts)
137 const dllfunction_t *func;
138 dllhandle_t dllhandle = 0;
145 #ifdef PREFER_PRELOAD
146 dllhandle = dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL);
147 if(Sys_LoadDependencyFunctions(dllhandle, fcts, false, false))
149 Con_DPrintf ("All of %s's functions were already linked in! Not loading dynamically...\n", dllnames[0]);
154 Sys_FreeLibrary(&dllhandle);
160 for (func = fcts; func && func->name != NULL; func++)
161 *func->funcvariable = NULL;
163 // Try every possible name
164 Con_DPrintf ("Trying to load library...");
165 for (i = 0; dllnames[i] != NULL; i++)
167 Con_DPrintf (" \"%s\"", dllnames[i]);
169 # ifndef DONT_USE_SETDLLDIRECTORY
171 SetDllDirectory("bin64");
173 SetDllDirectory("bin32");
177 if(Sys_LoadLibrary(dllnames[i], &dllhandle))
179 if (Sys_LoadDependencyFunctions(dllhandle, fcts, true, (dllnames[i+1] != NULL) || (strrchr(sys.argv[0], '/'))))
182 Sys_FreeLibrary (&dllhandle);
186 // see if the names can be loaded relative to the executable path
187 // (this is for Mac OSX which does not check next to the executable)
188 if (!dllhandle && strrchr(sys.argv[0], '/'))
190 char path[MAX_OSPATH];
191 strlcpy(path, sys.argv[0], sizeof(path));
192 strrchr(path, '/')[1] = 0;
193 for (i = 0; dllnames[i] != NULL; i++)
195 char temp[MAX_OSPATH];
196 strlcpy(temp, path, sizeof(temp));
197 strlcat(temp, dllnames[i], sizeof(temp));
198 Con_DPrintf (" \"%s\"", temp);
200 if(Sys_LoadLibrary(temp, &dllhandle))
202 if (Sys_LoadDependencyFunctions(dllhandle, fcts, true, (dllnames[i+1] != NULL) || (strrchr(sys.argv[0], '/'))))
205 Sys_FreeLibrary (&dllhandle);
213 Con_DPrintf(" - failed.\n");
217 Con_DPrintf(" - loaded.\n");
218 Con_Printf("Loaded library \"%s\"\n", dllnames[i]);
227 qbool Sys_LoadLibrary(const char *name, dllhandle_t *handle)
229 dllhandle_t dllhandle = 0;
236 dllhandle = LoadLibrary (name);
238 dllhandle = dlopen (name, RTLD_LAZY | RTLD_GLOBAL);
248 void Sys_FreeLibrary (dllhandle_t* handle)
251 if (handle == NULL || *handle == NULL)
255 FreeLibrary (*handle);
264 void* Sys_GetProcAddress (dllhandle_t handle, const char* name)
268 return (void *)GetProcAddress (handle, name);
270 return (void *)dlsym (handle, name);
278 # define HAVE_TIMEGETTIME 1
279 # define HAVE_QUERYPERFORMANCECOUNTER 1
280 # define HAVE_Sleep 1
284 #if defined(CLOCK_MONOTONIC) || defined(CLOCK_HIRES)
285 # define HAVE_CLOCKGETTIME 1
287 // FIXME improve this check, manpage hints to DST_NONE
288 # define HAVE_GETTIMEOFDAY 1
292 // on Win32, select() cannot be used with all three FD list args being NULL according to MSDN
293 // (so much for POSIX...)
295 # define HAVE_SELECT 1
300 // FIXME improve this check
301 # define HAVE_USLEEP 1
304 // these are referenced elsewhere
305 cvar_t sys_usenoclockbutbenchmark = {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "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."};
306 cvar_t sys_libdir = {CF_READONLY | CF_CLIENT | CF_SERVER, "sys_libdir", "", "Default engine library directory"};
309 static cvar_t sys_debugsleep = {CF_CLIENT | CF_SERVER, "sys_debugsleep", "0", "write requested and attained sleep times to standard output, to be used with gnuplot"};
310 static cvar_t sys_usesdlgetticks = {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sys_usesdlgetticks", "0", "use SDL_GetTicks() timer (less accurate, for debugging)"};
311 static cvar_t sys_usesdldelay = {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sys_usesdldelay", "0", "use SDL_Delay() (less accurate, for debugging)"};
312 #if HAVE_QUERYPERFORMANCECOUNTER
313 static cvar_t sys_usequeryperformancecounter = {CF_CLIENT | CF_SERVER | 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)"};
315 #if HAVE_CLOCKGETTIME
316 static cvar_t sys_useclockgettime = {CF_CLIENT | CF_SERVER | 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)"};
319 static double benchmark_time; // actually always contains an integer amount of milliseconds, will eventually "overflow"
325 Returns the position (1 to argc-1) in the program's argument list
326 where the given parameter apears, or 0 if not present
329 int Sys_CheckParm (const char *parm)
333 for (i=1 ; i<sys.argc ; i++)
336 continue; // NEXTSTEP sometimes clears appkit vars.
337 if (!strcmp (parm,sys.argv[i]))
344 void Sys_Init_Commands (void)
346 Cvar_RegisterVariable(&sys_debugsleep);
347 Cvar_RegisterVariable(&sys_usenoclockbutbenchmark);
348 Cvar_RegisterVariable(&sys_libdir);
349 #if HAVE_TIMEGETTIME || HAVE_QUERYPERFORMANCECOUNTER || HAVE_CLOCKGETTIME || HAVE_GETTIMEOFDAY
350 if(sys_supportsdlgetticks)
352 Cvar_RegisterVariable(&sys_usesdlgetticks);
353 Cvar_RegisterVariable(&sys_usesdldelay);
356 #if HAVE_QUERYPERFORMANCECOUNTER
357 Cvar_RegisterVariable(&sys_usequeryperformancecounter);
359 #if HAVE_CLOCKGETTIME
360 Cvar_RegisterVariable(&sys_useclockgettime);
364 double Sys_DirtyTime(void)
366 // first all the OPTIONAL timers
368 // benchmark timer (fake clock)
369 if(sys_usenoclockbutbenchmark.integer)
371 double old_benchmark_time = benchmark_time;
373 if(benchmark_time == old_benchmark_time)
374 Sys_Error("sys_usenoclockbutbenchmark cannot run any longer, sorry");
375 return benchmark_time * 0.000001;
377 #if HAVE_QUERYPERFORMANCECOUNTER
378 if (sys_usequeryperformancecounter.integer)
380 // LadyHavoc: note to people modifying this code, DWORD is specifically defined as an unsigned 32bit number, therefore the 65536.0 * 65536.0 is fine.
381 // QueryPerformanceCounter
383 // Windows 95/98/ME/NT/2000/XP
385 // very accurate (CPU cycles)
387 // does not necessarily match realtime too well (tends to get faster and faster in win98)
388 // wraps around occasionally on some platforms (depends on CPU speed and probably other unknown factors)
390 LARGE_INTEGER PerformanceFreq;
391 LARGE_INTEGER PerformanceCount;
393 if (QueryPerformanceFrequency (&PerformanceFreq))
395 QueryPerformanceCounter (&PerformanceCount);
397 timescale = 1.0 / ((double) PerformanceFreq.LowPart + (double) PerformanceFreq.HighPart * 65536.0 * 65536.0);
398 return ((double) PerformanceCount.LowPart + (double) PerformanceCount.HighPart * 65536.0 * 65536.0) * timescale;
402 Con_Printf("No hardware timer available\n");
403 // fall back to other clock sources
404 Cvar_SetValueQuick(&sys_usequeryperformancecounter, false);
409 #if HAVE_CLOCKGETTIME
410 if (sys_useclockgettime.integer)
413 # ifdef CLOCK_MONOTONIC
415 clock_gettime(CLOCK_MONOTONIC, &ts);
418 clock_gettime(CLOCK_HIGHRES, &ts);
420 return (double) ts.tv_sec + ts.tv_nsec / 1000000000.0;
424 // now all the FALLBACK timers
425 if(sys_supportsdlgetticks && sys_usesdlgetticks.integer)
426 return (double) Sys_SDL_GetTicks() / 1000.0;
427 #if HAVE_GETTIMEOFDAY
430 gettimeofday(&tp, NULL);
431 return (double) tp.tv_sec + tp.tv_usec / 1000000.0;
433 #elif HAVE_TIMEGETTIME
435 static int firsttimegettime = true;
438 // Windows 95/98/ME/NT/2000/XP
440 // reasonable accuracy (millisecond)
442 // wraps around every 47 days or so (but this is non-fatal to us, odd times are rejected, only causes a one frame stutter)
444 // make sure the timer is high precision, otherwise different versions of windows have varying accuracy
445 if (firsttimegettime)
448 firsttimegettime = false;
451 return (double) timeGetTime() / 1000.0;
454 // fallback for using the SDL timer if no other timer is available
455 // this calls Sys_Error() if not linking against SDL
456 return (double) Sys_SDL_GetTicks() / 1000.0;
460 void Sys_Sleep(int microseconds)
463 if(sys_usenoclockbutbenchmark.integer)
467 double old_benchmark_time = benchmark_time;
468 benchmark_time += microseconds;
469 if(benchmark_time == old_benchmark_time)
470 Sys_Error("sys_usenoclockbutbenchmark cannot run any longer, sorry");
474 if(sys_debugsleep.integer)
478 if(sys_supportsdlgetticks && sys_usesdldelay.integer)
480 Sys_SDL_Delay(microseconds / 1000);
486 tv.tv_sec = microseconds / 1000000;
487 tv.tv_usec = microseconds % 1000000;
488 select(0, NULL, NULL, NULL, &tv);
493 usleep(microseconds);
498 Sleep(microseconds / 1000);
503 Sys_SDL_Delay(microseconds / 1000);
506 if(sys_debugsleep.integer)
508 t = Sys_DirtyTime() - t;
509 Sys_PrintfToTerminal("%d %d # debugsleep\n", microseconds, (unsigned int)(t * 1000000));
513 void Sys_PrintfToTerminal(const char *fmt, ...)
516 char msg[MAX_INPUTLINE];
518 va_start(argptr,fmt);
519 dpvsnprintf(msg,sizeof(msg),fmt,argptr);
522 Sys_PrintToTerminal(msg);
526 static const char *Sys_FindInPATH(const char *name, char namesep, const char *PATH, char pathsep, char *buf, size_t bufsize)
528 const char *p = PATH;
532 while((q = strchr(p, ':')))
534 dpsnprintf(buf, bufsize, "%.*s%c%s", (int)(q-p), p, namesep, name);
535 if(FS_SysFileExists(buf))
539 if(!q) // none found - try the last item
541 dpsnprintf(buf, bufsize, "%s%c%s", p, namesep, name);
542 if(FS_SysFileExists(buf))
550 static const char *Sys_FindExecutableName(void)
555 static char exenamebuf[MAX_OSPATH+1];
557 #if defined(__FreeBSD__)
558 int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
559 size_t exenamebuflen = sizeof(exenamebuf)-1;
560 if (sysctl(mib, 4, exenamebuf, &exenamebuflen, NULL, 0) == 0)
564 #elif defined(__linux__)
565 n = readlink("/proc/self/exe", exenamebuf, sizeof(exenamebuf)-1);
567 if(n > 0 && (size_t)(n) < sizeof(exenamebuf))
572 if(strchr(sys.argv[0], '/'))
573 return sys.argv[0]; // possibly a relative path
575 return Sys_FindInPATH(sys.argv[0], '/', getenv("PATH"), ':', exenamebuf, sizeof(exenamebuf));
579 void Sys_ProvideSelfFD(void)
583 sys.selffd = FS_SysOpenFD(Sys_FindExecutableName(), "rb", false);
586 // for x86 cpus only... (x64 has SSE2_PRESENT)
587 #if defined(SSE_POSSIBLE) && !defined(SSE2_PRESENT)
588 // code from SDL, shortened as we can expect CPUID to work
589 static int CPUID_Features(void)
592 # if (defined(__GNUC__) || defined(__clang__) || defined(__TINYC__)) && defined(__i386__)
594 " movl %%ebx,%%edi\n"
595 " xorl %%eax,%%eax \n"
597 " cpuid # Get family/model/stepping/features\n"
599 " movl %%edi,%%ebx\n"
602 : "%eax", "%ecx", "%edx", "%edi"
604 # elif (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)
608 cpuid ; Get family/model/stepping/features
612 # error SSE_POSSIBLE set but no CPUID implementation
619 qbool Sys_HaveSSE(void)
621 // COMMANDLINEOPTION: SSE: -nosse disables SSE support and detection
622 if(Sys_CheckParm("-nosse"))
627 // COMMANDLINEOPTION: SSE: -forcesse enables SSE support and disables detection
628 if(Sys_CheckParm("-forcesse") || Sys_CheckParm("-forcesse2"))
630 if(CPUID_Features() & (1 << 25))
636 qbool Sys_HaveSSE2(void)
638 // COMMANDLINEOPTION: SSE2: -nosse2 disables SSE2 support and detection
639 if(Sys_CheckParm("-nosse") || Sys_CheckParm("-nosse2"))
644 // COMMANDLINEOPTION: SSE2: -forcesse2 enables SSE2 support and disables detection
645 if(Sys_CheckParm("-forcesse2"))
647 if((CPUID_Features() & (3 << 25)) == (3 << 25)) // SSE is 1<<25, SSE2 is 1<<26
654 /// called to set process priority for dedicated servers
655 #if defined(__linux__)
656 #include <sys/resource.h>
659 void Sys_InitProcessNice (void)
662 sys.nicepossible = false;
663 if(Sys_CheckParm("-nonice"))
666 sys.nicelevel = getpriority(PRIO_PROCESS, 0);
669 Con_Printf("Kernel does not support reading process priority - cannot use niceness\n");
672 if(getrlimit(RLIMIT_NICE, &lim))
674 Con_Printf("Kernel does not support lowering nice level again - cannot use niceness\n");
677 if(lim.rlim_cur != RLIM_INFINITY && sys.nicelevel < (int) (20 - lim.rlim_cur))
679 Con_Printf("Current nice level is below the soft limit - cannot use niceness\n");
682 sys.nicepossible = true;
685 void Sys_MakeProcessNice (void)
687 if(!sys.nicepossible)
691 Con_DPrintf("Process is becoming 'nice'...\n");
692 if(setpriority(PRIO_PROCESS, 0, 19))
693 Con_Printf(CON_ERROR "Failed to raise nice level to %d\n", 19);
696 void Sys_MakeProcessMean (void)
698 if(!sys.nicepossible)
702 Con_DPrintf("Process is becoming 'mean'...\n");
703 if(setpriority(PRIO_PROCESS, 0, sys.nicelevel))
704 Con_Printf(CON_ERROR "Failed to lower nice level to %d\n", sys.nicelevel);
708 void Sys_InitProcessNice (void)
711 void Sys_MakeProcessNice (void)
714 void Sys_MakeProcessMean (void)