sys_shared.c

   1 #ifdef WIN32
   2 # ifndef DONT_USE_SETDLLDIRECTORY
   3 #  define _WIN32_WINNT 0x0502
   4 # endif
   5 #endif
   6
   7 #include "quakedef.h"
   8 #include "taskqueue.h"
   9 #include "thread.h"
  10
  11 #define SUPPORTDLL
  12
  13 #ifdef WIN32
  14 # include <windows.h>
  15 # include <mmsystem.h> // timeGetTime
  16 # include <time.h> // localtime
  17 #ifdef _MSC_VER
  18 #pragma comment(lib, "winmm.lib")
  19 #endif
  20 #else
  21 # ifdef __FreeBSD__
  22 #  include <sys/sysctl.h>
  23 # endif
  24 # include <unistd.h>
  25 # include <fcntl.h>
  26 # include <sys/time.h>
  27 # include <time.h>
  28 # ifdef SUPPORTDLL
  29 #  include <dlfcn.h>
  30 # endif
  31 #endif
  32
  33 static char sys_timestring[128];
  34 char *Sys_TimeString(const char *timeformat)
  35 {
  36         time_t mytime = time(NULL);
  37 #if _MSC_VER >= 1400
  38         struct tm mytm;
  39         localtime_s(&mytm, &mytime);
  40         strftime(sys_timestring, sizeof(sys_timestring), timeformat, &mytm);
  41 #else
  42         strftime(sys_timestring, sizeof(sys_timestring), timeformat, localtime(&mytime));
  43 #endif
  44         return sys_timestring;
  45 }
  46
  47
  48 void Sys_Quit (int returnvalue)
  49 {
  50         // Unlock mutexes because the quit command may jump directly here, causing a deadlock
  51         if ((cmd_local)->cbuf->lock)
  52                 Cbuf_Unlock((cmd_local)->cbuf);
  53         SV_UnlockThreadMutex();
  54         TaskQueue_Frame(true);
  55
  56         if (Sys_CheckParm("-profilegameonly"))
  57                 Sys_AllowProfiling(false);
  58         host.state = host_shutdown;
  59         Host_Shutdown();
  60         exit(returnvalue);
  61 }
  62
  63 #ifdef __cplusplus
  64 extern "C"
  65 #endif
  66 void Sys_AllowProfiling(qbool enable)
  67 {
  68 #ifdef __ANDROID__
  69 #ifdef USE_PROFILER
  70         extern void monstartup(const char *libname);
  71         extern void moncleanup(void);
  72         if (enable)
  73                 monstartup("libmain.so");
  74         else
  75                 moncleanup();
  76 #endif
  77 #elif (defined(__linux__) && (defined(__GLIBC__) || defined(__GNU_LIBRARY__))) || defined(__FreeBSD__)
  78         extern int moncontrol(int);
  79         moncontrol(enable);
  80 #endif
  81 }
  82
  83
  84 /*
  85 ===============================================================================
  86
  87 DLL MANAGEMENT
  88
  89 ===============================================================================
  90 */
  91
  92 static qbool Sys_LoadDependencyFunctions(dllhandle_t dllhandle, const dllfunction_t *fcts, qbool complain, qbool has_next)
  93 {
  94         const dllfunction_t *func;
  95         if(dllhandle)
  96         {
  97                 for (func = fcts; func && func->name != NULL; func++)
  98                         if (!(*func->funcvariable = (void *) Sys_GetProcAddress (dllhandle, func->name)))
  99                         {
 100                                 if(complain)
 101                                 {
 102                                         Con_DPrintf (" - missing function \"%s\" - broken library!", func->name);
 103                                         if(has_next)
 104                                                 Con_DPrintf("\nContinuing with");
 105                                 }
 106                                 goto notfound;
 107                         }
 108                 return true;
 109
 110         notfound:
 111                 for (func = fcts; func && func->name != NULL; func++)
 112                         *func->funcvariable = NULL;
 113         }
 114         return false;
 115 }
 116
 117 qbool Sys_LoadSelf(dllhandle_t *handle)
 118 {
 119         dllhandle_t dllhandle = 0;
 120
 121         if (handle == NULL)
 122                 return false;
 123 #ifdef WIN32
 124         dllhandle = LoadLibrary (NULL);
 125 #else
 126         dllhandle = dlopen (NULL, RTLD_NOW | RTLD_GLOBAL);
 127 #endif
 128         *handle = dllhandle;
 129         return true;
 130 }
 131
 132 qbool Sys_LoadDependency (const char** dllnames, dllhandle_t* handle, const dllfunction_t *fcts)
 133 {
 134 #ifdef SUPPORTDLL
 135         const dllfunction_t *func;
 136         dllhandle_t dllhandle = 0;
 137         unsigned int i;
 138
 139         if (handle == NULL)
 140                 return false;
 141
 142 #ifndef WIN32
 143 #ifdef PREFER_PRELOAD
 144         dllhandle = dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL);
 145         if(Sys_LoadDependencyFunctions(dllhandle, fcts, false, false))
 146         {
 147                 Con_DPrintf ("All of %s's functions were already linked in! Not loading dynamically...\n", dllnames[0]);
 148                 *handle = dllhandle;
 149                 return true;
 150         }
 151         else
 152                 Sys_FreeLibrary(&dllhandle);
 153 notfound:
 154 #endif
 155 #endif
 156
 157         // Initializations
 158         for (func = fcts; func && func->name != NULL; func++)
 159                 *func->funcvariable = NULL;
 160
 161         // Try every possible name
 162         Con_DPrintf ("Trying to load library...");
 163         for (i = 0; dllnames[i] != NULL; i++)
 164         {
 165                 Con_DPrintf (" \"%s\"", dllnames[i]);
 166 #ifdef WIN32
 167 # ifndef DONT_USE_SETDLLDIRECTORY
 168 #  ifdef _WIN64
 169                 SetDllDirectory("bin64");
 170 #  else
 171                 SetDllDirectory("bin32");
 172 #  endif
 173 # endif
 174 #endif
 175                 if(Sys_LoadLibrary(dllnames[i], &dllhandle))
 176                 {
 177                         if (Sys_LoadDependencyFunctions(dllhandle, fcts, true, (dllnames[i+1] != NULL) || (strrchr(sys.argv[0], '/'))))
 178                                 break;
 179                         else
 180                                 Sys_FreeLibrary (&dllhandle);
 181                 }
 182         }
 183
 184         // see if the names can be loaded relative to the executable path
 185         // (this is for Mac OSX which does not check next to the executable)
 186         if (!dllhandle && strrchr(sys.argv[0], '/'))
 187         {
 188                 char path[MAX_OSPATH];
 189                 strlcpy(path, sys.argv[0], sizeof(path));
 190                 strrchr(path, '/')[1] = 0;
 191                 for (i = 0; dllnames[i] != NULL; i++)
 192                 {
 193                         char temp[MAX_OSPATH];
 194                         strlcpy(temp, path, sizeof(temp));
 195                         strlcat(temp, dllnames[i], sizeof(temp));
 196                         Con_DPrintf (" \"%s\"", temp);
 197
 198                         if(Sys_LoadLibrary(temp, &dllhandle))
 199                         {
 200                                 if (Sys_LoadDependencyFunctions(dllhandle, fcts, true, (dllnames[i+1] != NULL) || (strrchr(sys.argv[0], '/'))))
 201                                         break;
 202                                 else
 203                                         Sys_FreeLibrary (&dllhandle);
 204                         }
 205                 }
 206         }
 207
 208         // No DLL found
 209         if (! dllhandle)
 210         {
 211                 Con_DPrintf(" - failed.\n");
 212                 return false;
 213         }
 214
 215         Con_DPrintf(" - loaded.\n");
 216         Con_Printf("Loaded library \"%s\"\n", dllnames[i]);
 217
 218         *handle = dllhandle;
 219         return true;
 220 #else
 221         return false;
 222 #endif
 223 }
 224
 225 qbool Sys_LoadLibrary(const char *name, dllhandle_t *handle)
 226 {
 227         dllhandle_t dllhandle = 0;
 228
 229         if(handle == NULL)
 230                 return false;
 231
 232 #ifdef SUPPORTDLL
 233 # ifdef WIN32
 234         dllhandle = LoadLibrary (name);
 235 # else
 236         dllhandle = dlopen (name, RTLD_LAZY | RTLD_GLOBAL);
 237 # endif
 238 #endif
 239         if(!dllhandle)
 240                 return false;
 241
 242         *handle = dllhandle;
 243         return true;
 244 }
 245
 246 void Sys_FreeLibrary (dllhandle_t* handle)
 247 {
 248 #ifdef SUPPORTDLL
 249         if (handle == NULL || *handle == NULL)
 250                 return;
 251
 252 #ifdef WIN32
 253         FreeLibrary (*handle);
 254 #else
 255         dlclose (*handle);
 256 #endif
 257
 258         *handle = NULL;
 259 #endif
 260 }
 261
 262 void* Sys_GetProcAddress (dllhandle_t handle, const char* name)
 263 {
 264 #ifdef SUPPORTDLL
 265 #ifdef WIN32
 266         return (void *)GetProcAddress (handle, name);
 267 #else
 268         return (void *)dlsym (handle, name);
 269 #endif
 270 #else
 271         return NULL;
 272 #endif
 273 }
 274
 275 #ifdef WIN32
 276 # define HAVE_TIMEGETTIME 1
 277 # define HAVE_QUERYPERFORMANCECOUNTER 1
 278 # define HAVE_Sleep 1
 279 #endif
 280
 281 #ifndef WIN32
 282 #if defined(CLOCK_MONOTONIC) || defined(CLOCK_HIRES)
 283 # define HAVE_CLOCKGETTIME 1
 284 #endif
 285 // FIXME improve this check, manpage hints to DST_NONE
 286 # define HAVE_GETTIMEOFDAY 1
 287 #endif
 288
 289 #ifndef WIN32
 290 // on Win32, select() cannot be used with all three FD list args being NULL according to MSDN
 291 // (so much for POSIX...)
 292 # ifdef FD_SET
 293 #  define HAVE_SELECT 1
 294 # endif
 295 #endif
 296
 297 #ifndef WIN32
 298 // FIXME improve this check
 299 # define HAVE_USLEEP 1
 300 #endif
 301
 302 // these are referenced elsewhere
 303 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."};
 304 cvar_t sys_libdir = {CF_READONLY | CF_CLIENT | CF_SERVER, "sys_libdir", "", "Default engine library directory"};
 305
 306 // these are not
 307 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"};
 308 static cvar_t sys_usesdlgetticks = {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sys_usesdlgetticks", "0", "use SDL_GetTicks() timer (less accurate, for debugging)"};
 309 static cvar_t sys_usesdldelay = {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "sys_usesdldelay", "0", "use SDL_Delay() (less accurate, for debugging)"};
 310 #if HAVE_QUERYPERFORMANCECOUNTER
 311 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)"};
 312 #endif
 313 #if HAVE_CLOCKGETTIME
 314 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)"};
 315 #endif
 316
 317 static double benchmark_time; // actually always contains an integer amount of milliseconds, will eventually "overflow"
 318
 319 /*
 320 ================
 321 Sys_CheckParm
 322
 323 Returns the position (1 to argc-1) in the program's argument list
 324 where the given parameter apears, or 0 if not present
 325 ================
 326 */
 327 int Sys_CheckParm (const char *parm)
 328 {
 329         int i;
 330
 331         for (i=1 ; i<sys.argc ; i++)
 332         {
 333                 if (!sys.argv[i])
 334                         continue;               // NEXTSTEP sometimes clears appkit vars.
 335                 if (!strcmp (parm,sys.argv[i]))
 336                         return i;
 337         }
 338
 339         return 0;
 340 }
 341
 342 void Sys_Init_Commands (void)
 343 {
 344         Cvar_RegisterVariable(&sys_debugsleep);
 345         Cvar_RegisterVariable(&sys_usenoclockbutbenchmark);
 346         Cvar_RegisterVariable(&sys_libdir);
 347 #if HAVE_TIMEGETTIME || HAVE_QUERYPERFORMANCECOUNTER || HAVE_CLOCKGETTIME || HAVE_GETTIMEOFDAY
 348         if(sys_supportsdlgetticks)
 349         {
 350                 Cvar_RegisterVariable(&sys_usesdlgetticks);
 351                 Cvar_RegisterVariable(&sys_usesdldelay);
 352         }
 353 #endif
 354 #if HAVE_QUERYPERFORMANCECOUNTER
 355         Cvar_RegisterVariable(&sys_usequeryperformancecounter);
 356 #endif
 357 #if HAVE_CLOCKGETTIME
 358         Cvar_RegisterVariable(&sys_useclockgettime);
 359 #endif
 360 }
 361
 362 double Sys_DirtyTime(void)
 363 {
 364         // first all the OPTIONAL timers
 365
 366         // benchmark timer (fake clock)
 367         if(sys_usenoclockbutbenchmark.integer)
 368         {
 369                 double old_benchmark_time = benchmark_time;
 370                 benchmark_time += 1;
 371                 if(benchmark_time == old_benchmark_time)
 372                         Sys_Error("sys_usenoclockbutbenchmark cannot run any longer, sorry");
 373                 return benchmark_time * 0.000001;
 374         }
 375 #if HAVE_QUERYPERFORMANCECOUNTER
 376         if (sys_usequeryperformancecounter.integer)
 377         {
 378                 // LadyHavoc: note to people modifying this code, DWORD is specifically defined as an unsigned 32bit number, therefore the 65536.0 * 65536.0 is fine.
 379                 // QueryPerformanceCounter
 380                 // platform:
 381                 // Windows 95/98/ME/NT/2000/XP
 382                 // features:
 383                 // very accurate (CPU cycles)
 384                 // known issues:
 385                 // does not necessarily match realtime too well (tends to get faster and faster in win98)
 386                 // wraps around occasionally on some platforms (depends on CPU speed and probably other unknown factors)
 387                 double timescale;
 388                 LARGE_INTEGER PerformanceFreq;
 389                 LARGE_INTEGER PerformanceCount;
 390
 391                 if (QueryPerformanceFrequency (&PerformanceFreq))
 392                 {
 393                         QueryPerformanceCounter (&PerformanceCount);
 394
 395                         timescale = 1.0 / ((double) PerformanceFreq.LowPart + (double) PerformanceFreq.HighPart * 65536.0 * 65536.0);
 396                         return ((double) PerformanceCount.LowPart + (double) PerformanceCount.HighPart * 65536.0 * 65536.0) * timescale;
 397                 }
 398                 else
 399                 {
 400                         Con_Printf("No hardware timer available\n");
 401                         // fall back to other clock sources
 402                         Cvar_SetValueQuick(&sys_usequeryperformancecounter, false);
 403                 }
 404         }
 405 #endif
 406
 407 #if HAVE_CLOCKGETTIME
 408         if (sys_useclockgettime.integer)
 409         {
 410                 struct timespec ts;
 411 #  ifdef CLOCK_MONOTONIC
 412                 // linux
 413                 clock_gettime(CLOCK_MONOTONIC, &ts);
 414 #  else
 415                 // sunos
 416                 clock_gettime(CLOCK_HIGHRES, &ts);
 417 #  endif
 418                 return (double) ts.tv_sec + ts.tv_nsec / 1000000000.0;
 419         }
 420 #endif
 421
 422         // now all the FALLBACK timers
 423         if(sys_supportsdlgetticks && sys_usesdlgetticks.integer)
 424                 return (double) Sys_SDL_GetTicks() / 1000.0;
 425 #if HAVE_GETTIMEOFDAY
 426         {
 427                 struct timeval tp;
 428                 gettimeofday(&tp, NULL);
 429                 return (double) tp.tv_sec + tp.tv_usec / 1000000.0;
 430         }
 431 #elif HAVE_TIMEGETTIME
 432         {
 433                 static int firsttimegettime = true;
 434                 // timeGetTime
 435                 // platform:
 436                 // Windows 95/98/ME/NT/2000/XP
 437                 // features:
 438                 // reasonable accuracy (millisecond)
 439                 // issues:
 440                 // wraps around every 47 days or so (but this is non-fatal to us, odd times are rejected, only causes a one frame stutter)
 441
 442                 // make sure the timer is high precision, otherwise different versions of windows have varying accuracy
 443                 if (firsttimegettime)
 444                 {
 445                         timeBeginPeriod(1);
 446                         firsttimegettime = false;
 447                 }
 448
 449                 return (double) timeGetTime() / 1000.0;
 450         }
 451 #else
 452         // fallback for using the SDL timer if no other timer is available
 453         // this calls Sys_Error() if not linking against SDL
 454         return (double) Sys_SDL_GetTicks() / 1000.0;
 455 #endif
 456 }
 457
 458 void Sys_Sleep(int microseconds)
 459 {
 460         double t = 0;
 461         if(sys_usenoclockbutbenchmark.integer)
 462         {
 463                 if(microseconds)
 464                 {
 465                         double old_benchmark_time = benchmark_time;
 466                         benchmark_time += microseconds;
 467                         if(benchmark_time == old_benchmark_time)
 468                                 Sys_Error("sys_usenoclockbutbenchmark cannot run any longer, sorry");
 469                 }
 470                 return;
 471         }
 472         if(sys_debugsleep.integer)
 473         {
 474                 t = Sys_DirtyTime();
 475         }
 476         if(sys_supportsdlgetticks && sys_usesdldelay.integer)
 477         {
 478                 Sys_SDL_Delay(microseconds / 1000);
 479         }
 480 #if HAVE_SELECT
 481         else
 482         {
 483                 struct timeval tv;
 484                 tv.tv_sec = microseconds / 1000000;
 485                 tv.tv_usec = microseconds % 1000000;
 486                 select(0, NULL, NULL, NULL, &tv);
 487         }
 488 #elif HAVE_USLEEP
 489         else
 490         {
 491                 usleep(microseconds);
 492         }
 493 #elif HAVE_Sleep
 494         else
 495         {
 496                 Sleep(microseconds / 1000);
 497         }
 498 #else
 499         else
 500         {
 501                 Sys_SDL_Delay(microseconds / 1000);
 502         }
 503 #endif
 504         if(sys_debugsleep.integer)
 505         {
 506                 t = Sys_DirtyTime() - t;
 507                 Sys_PrintfToTerminal("%d %d # debugsleep\n", microseconds, (unsigned int)(t * 1000000));
 508         }
 509 }
 510
 511 void Sys_PrintfToTerminal(const char *fmt, ...)
 512 {
 513         va_list argptr;
 514         char msg[MAX_INPUTLINE];
 515
 516         va_start(argptr,fmt);
 517         dpvsnprintf(msg,sizeof(msg),fmt,argptr);
 518         va_end(argptr);
 519
 520         Sys_PrintToTerminal(msg);
 521 }
 522
 523 #ifndef WIN32
 524 static const char *Sys_FindInPATH(const char *name, char namesep, const char *PATH, char pathsep, char *buf, size_t bufsize)
 525 {
 526         const char *p = PATH;
 527         const char *q;
 528         if(p && name)
 529         {
 530                 while((q = strchr(p, ':')))
 531                 {
 532                         dpsnprintf(buf, bufsize, "%.*s%c%s", (int)(q-p), p, namesep, name);
 533                         if(FS_SysFileExists(buf))
 534                                 return buf;
 535                         p = q + 1;
 536                 }
 537                 if(!q) // none found - try the last item
 538                 {
 539                         dpsnprintf(buf, bufsize, "%s%c%s", p, namesep, name);
 540                         if(FS_SysFileExists(buf))
 541                                 return buf;
 542                 }
 543         }
 544         return name;
 545 }
 546 #endif
 547
 548 static const char *Sys_FindExecutableName(void)
 549 {
 550 #if defined(WIN32)
 551         return sys.argv[0];
 552 #else
 553         static char exenamebuf[MAX_OSPATH+1];
 554         ssize_t n = -1;
 555 #if defined(__FreeBSD__)
 556         int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
 557         size_t exenamebuflen = sizeof(exenamebuf)-1;
 558         if (sysctl(mib, 4, exenamebuf, &exenamebuflen, NULL, 0) == 0)
 559         {
 560                 n = exenamebuflen;
 561         }
 562 #elif defined(__linux__)
 563         n = readlink("/proc/self/exe", exenamebuf, sizeof(exenamebuf)-1);
 564 #endif
 565         if(n > 0 && (size_t)(n) < sizeof(exenamebuf))
 566         {
 567                 exenamebuf[n] = 0;
 568                 return exenamebuf;
 569         }
 570         if(strchr(sys.argv[0], '/'))
 571                 return sys.argv[0]; // possibly a relative path
 572         else
 573                 return Sys_FindInPATH(sys.argv[0], '/', getenv("PATH"), ':', exenamebuf, sizeof(exenamebuf));
 574 #endif
 575 }
 576
 577 void Sys_ProvideSelfFD(void)
 578 {
 579         if(sys.selffd != -1)
 580                 return;
 581         sys.selffd = FS_SysOpenFD(Sys_FindExecutableName(), "rb", false);
 582 }
 583
 584 // for x86 cpus only...  (x64 has SSE2_PRESENT)
 585 #if defined(SSE_POSSIBLE) && !defined(SSE2_PRESENT)
 586 // code from SDL, shortened as we can expect CPUID to work
 587 static int CPUID_Features(void)
 588 {
 589         int features = 0;
 590 # if (defined(__GNUC__) || defined(__clang__) || defined(__TINYC__)) && defined(__i386__)
 591         __asm__ (
 592 "        movl    %%ebx,%%edi\n"
 593 "        xorl    %%eax,%%eax                                           \n"
 594 "        incl    %%eax                                                 \n"
 595 "        cpuid                       # Get family/model/stepping/features\n"
 596 "        movl    %%edx,%0                                              \n"
 597 "        movl    %%edi,%%ebx\n"
 598         : "=m" (features)
 599         :
 600         : "%eax", "%ecx", "%edx", "%edi"
 601         );
 602 # elif (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)
 603         __asm {
 604         xor     eax, eax
 605         inc     eax
 606         cpuid                       ; Get family/model/stepping/features
 607         mov     features, edx
 608         }
 609 # else
 610 #  error SSE_POSSIBLE set but no CPUID implementation
 611 # endif
 612         return features;
 613 }
 614 #endif
 615
 616 #ifdef SSE_POSSIBLE
 617 qbool Sys_HaveSSE(void)
 618 {
 619         // COMMANDLINEOPTION: SSE: -nosse disables SSE support and detection
 620         if(Sys_CheckParm("-nosse"))
 621                 return false;
 622 #ifdef SSE_PRESENT
 623         return true;
 624 #else
 625         // COMMANDLINEOPTION: SSE: -forcesse enables SSE support and disables detection
 626         if(Sys_CheckParm("-forcesse") || Sys_CheckParm("-forcesse2"))
 627                 return true;
 628         if(CPUID_Features() & (1 << 25))
 629                 return true;
 630         return false;
 631 #endif
 632 }
 633
 634 qbool Sys_HaveSSE2(void)
 635 {
 636         // COMMANDLINEOPTION: SSE2: -nosse2 disables SSE2 support and detection
 637         if(Sys_CheckParm("-nosse") || Sys_CheckParm("-nosse2"))
 638                 return false;
 639 #ifdef SSE2_PRESENT
 640         return true;
 641 #else
 642         // COMMANDLINEOPTION: SSE2: -forcesse2 enables SSE2 support and disables detection
 643         if(Sys_CheckParm("-forcesse2"))
 644                 return true;
 645         if((CPUID_Features() & (3 << 25)) == (3 << 25)) // SSE is 1<<25, SSE2 is 1<<26
 646                 return true;
 647         return false;
 648 #endif
 649 }
 650 #endif
 651
 652 /// called to set process priority for dedicated servers
 653 #if defined(__linux__)
 654 #include <sys/resource.h>
 655 #include <errno.h>
 656
 657 void Sys_InitProcessNice (void)
 658 {
 659         struct rlimit lim;
 660         sys.nicepossible = false;
 661         if(Sys_CheckParm("-nonice"))
 662                 return;
 663         errno = 0;
 664         sys.nicelevel = getpriority(PRIO_PROCESS, 0);
 665         if(errno)
 666         {
 667                 Con_Printf("Kernel does not support reading process priority - cannot use niceness\n");
 668                 return;
 669         }
 670         if(getrlimit(RLIMIT_NICE, &lim))
 671         {
 672                 Con_Printf("Kernel does not support lowering nice level again - cannot use niceness\n");
 673                 return;
 674         }
 675         if(lim.rlim_cur != RLIM_INFINITY && sys.nicelevel < (int) (20 - lim.rlim_cur))
 676         {
 677                 Con_Printf("Current nice level is below the soft limit - cannot use niceness\n");
 678                 return;
 679         }
 680         sys.nicepossible = true;
 681         sys.isnice = false;
 682 }
 683 void Sys_MakeProcessNice (void)
 684 {
 685         if(!sys.nicepossible)
 686                 return;
 687         if(sys.isnice)
 688                 return;
 689         Con_DPrintf("Process is becoming 'nice'...\n");
 690         if(setpriority(PRIO_PROCESS, 0, 19))
 691                 Con_Printf(CON_ERROR "Failed to raise nice level to %d\n", 19);
 692         sys.isnice = true;
 693 }
 694 void Sys_MakeProcessMean (void)
 695 {
 696         if(!sys.nicepossible)
 697                 return;
 698         if(!sys.isnice)
 699                 return;
 700         Con_DPrintf("Process is becoming 'mean'...\n");
 701         if(setpriority(PRIO_PROCESS, 0, sys.nicelevel))
 702                 Con_Printf(CON_ERROR "Failed to lower nice level to %d\n", sys.nicelevel);
 703         sys.isnice = false;
 704 }
 705 #else
 706 void Sys_InitProcessNice (void)
 707 {
 708 }
 709 void Sys_MakeProcessNice (void)
 710 {
 711 }
 712 void Sys_MakeProcessMean (void)
 713 {
 714 }
 715 #endif