| 1 | /* Copyright (C) 2010-2020 The RetroArch team |
| 2 | * |
| 3 | * --------------------------------------------------------------------------------------- |
| 4 | * The following license statement only applies to this file (features_cpu.c). |
| 5 | * --------------------------------------------------------------------------------------- |
| 6 | * |
| 7 | * Permission is hereby granted, free of charge, |
| 8 | * to any person obtaining a copy of this software and associated documentation files (the "Software"), |
| 9 | * to deal in the Software without restriction, including without limitation the rights to |
| 10 | * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, |
| 11 | * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. |
| 14 | * |
| 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, |
| 16 | * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| 18 | * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
| 19 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 21 | */ |
| 22 | |
| 23 | #include <stdio.h> |
| 24 | #include <stdlib.h> |
| 25 | |
| 26 | #if defined(_WIN32) |
| 27 | #include <direct.h> |
| 28 | #else |
| 29 | #include <unistd.h> |
| 30 | #endif |
| 31 | |
| 32 | #include <compat/strl.h> |
| 33 | #include <streams/file_stream.h> |
| 34 | #include <libretro.h> |
| 35 | #include <features/features_cpu.h> |
| 36 | #include <retro_timers.h> |
| 37 | |
| 38 | #if defined(_WIN32) && !defined(_XBOX) |
| 39 | #include <windows.h> |
| 40 | #endif |
| 41 | |
| 42 | #ifdef __PSL1GHT__ |
| 43 | #include <lv2/systime.h> |
| 44 | #endif |
| 45 | |
| 46 | #if defined(_XBOX360) |
| 47 | #include <PPCIntrinsics.h> |
| 48 | #elif !defined(__MACH__) && (defined(__POWERPC__) || defined(__powerpc__) || defined(__ppc__) || defined(__PPC64__) || defined(__powerpc64__)) |
| 49 | #ifndef _PPU_INTRINSICS_H |
| 50 | #include <ppu_intrinsics.h> |
| 51 | #endif |
| 52 | #elif defined(_POSIX_MONOTONIC_CLOCK) || defined(ANDROID) || defined(__QNX__) || defined(DJGPP) |
| 53 | /* POSIX_MONOTONIC_CLOCK is not being defined in Android headers despite support being present. */ |
| 54 | #include <time.h> |
| 55 | #endif |
| 56 | |
| 57 | #if defined(__QNX__) && !defined(CLOCK_MONOTONIC) |
| 58 | #define CLOCK_MONOTONIC 2 |
| 59 | #endif |
| 60 | |
| 61 | #if defined(PSP) |
| 62 | #include <pspkernel.h> |
| 63 | #endif |
| 64 | |
| 65 | #if defined(PSP) || defined(__PSL1GHT__) |
| 66 | #include <sys/time.h> |
| 67 | #endif |
| 68 | |
| 69 | #if defined(PSP) |
| 70 | #include <psprtc.h> |
| 71 | #endif |
| 72 | |
| 73 | #if defined(VITA) |
| 74 | #include <psp2/kernel/processmgr.h> |
| 75 | #include <psp2/rtc.h> |
| 76 | #endif |
| 77 | |
| 78 | #if defined(ORBIS) |
| 79 | #include <orbis/libkernel.h> |
| 80 | #endif |
| 81 | |
| 82 | #if defined(PS2) |
| 83 | #include <ps2sdkapi.h> |
| 84 | #endif |
| 85 | |
| 86 | #if !defined(__PSL1GHT__) && defined(__PS3__) |
| 87 | #include <sys/sys_time.h> |
| 88 | #endif |
| 89 | |
| 90 | #ifdef GEKKO |
| 91 | #include <ogc/lwp_watchdog.h> |
| 92 | #endif |
| 93 | |
| 94 | #ifdef WIIU |
| 95 | #include <wiiu/os/time.h> |
| 96 | #endif |
| 97 | |
| 98 | #if defined(HAVE_LIBNX) |
| 99 | #include <switch.h> |
| 100 | #elif defined(SWITCH) |
| 101 | #include <libtransistor/types.h> |
| 102 | #include <libtransistor/svc.h> |
| 103 | #endif |
| 104 | |
| 105 | #if defined(_3DS) |
| 106 | #include <3ds/svc.h> |
| 107 | #include <3ds/os.h> |
| 108 | #include <3ds/services/cfgu.h> |
| 109 | #endif |
| 110 | |
| 111 | /* iOS/OSX specific. Lacks clock_gettime(), so implement it. */ |
| 112 | #ifdef __MACH__ |
| 113 | #include <sys/time.h> |
| 114 | |
| 115 | #ifndef CLOCK_MONOTONIC |
| 116 | #define CLOCK_MONOTONIC 0 |
| 117 | #endif |
| 118 | |
| 119 | #ifndef CLOCK_REALTIME |
| 120 | #define CLOCK_REALTIME 0 |
| 121 | #endif |
| 122 | |
| 123 | /** |
| 124 | * TODO/FIXME: clock_gettime function is part of iOS 10 now |
| 125 | **/ |
| 126 | static int ra_clock_gettime(int clk_ik, struct timespec *t) |
| 127 | { |
| 128 | struct timeval now; |
| 129 | int rv = gettimeofday(&now, NULL); |
| 130 | if (rv) |
| 131 | return rv; |
| 132 | t->tv_sec = now.tv_sec; |
| 133 | t->tv_nsec = now.tv_usec * 1000; |
| 134 | return 0; |
| 135 | } |
| 136 | #endif |
| 137 | |
| 138 | #if defined(__MACH__) && __IPHONE_OS_VERSION_MIN_REQUIRED < 100000 |
| 139 | #else |
| 140 | #define ra_clock_gettime clock_gettime |
| 141 | #endif |
| 142 | |
| 143 | #ifdef EMSCRIPTEN |
| 144 | #include <emscripten.h> |
| 145 | #endif |
| 146 | |
| 147 | #if defined(BSD) || defined(__APPLE__) |
| 148 | #include <sys/sysctl.h> |
| 149 | #endif |
| 150 | |
| 151 | #include <string.h> |
| 152 | |
| 153 | /** |
| 154 | * cpu_features_get_perf_counter: |
| 155 | * |
| 156 | * Gets performance counter. |
| 157 | * |
| 158 | * @return Performance counter. |
| 159 | **/ |
| 160 | retro_perf_tick_t cpu_features_get_perf_counter(void) |
| 161 | { |
| 162 | retro_perf_tick_t time_ticks = 0; |
| 163 | #if defined(_WIN32) |
| 164 | long tv_sec, tv_usec; |
| 165 | #if defined(_MSC_VER) && _MSC_VER <= 1200 |
| 166 | static const unsigned __int64 epoch = 11644473600000000; |
| 167 | #else |
| 168 | static const unsigned __int64 epoch = 11644473600000000ULL; |
| 169 | #endif |
| 170 | FILETIME file_time; |
| 171 | SYSTEMTIME system_time; |
| 172 | ULARGE_INTEGER ularge; |
| 173 | |
| 174 | GetSystemTime(&system_time); |
| 175 | SystemTimeToFileTime(&system_time, &file_time); |
| 176 | ularge.LowPart = file_time.dwLowDateTime; |
| 177 | ularge.HighPart = file_time.dwHighDateTime; |
| 178 | |
| 179 | tv_sec = (long)((ularge.QuadPart - epoch) / 10000000L); |
| 180 | tv_usec = (long)(system_time.wMilliseconds * 1000); |
| 181 | time_ticks = (1000000 * tv_sec + tv_usec); |
| 182 | #elif defined(GEKKO) |
| 183 | time_ticks = gettime(); |
| 184 | #elif !defined(__MACH__) && (defined(_XBOX360) || defined(__powerpc__) || defined(__ppc__) || defined(__POWERPC__) || defined(__PSL1GHT__) || defined(__PPC64__) || defined(__powerpc64__)) |
| 185 | time_ticks = __mftb(); |
| 186 | #elif (defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK > 0) || defined(__QNX__) || defined(ANDROID) |
| 187 | struct timespec tv; |
| 188 | if (ra_clock_gettime(CLOCK_MONOTONIC, &tv) == 0) |
| 189 | time_ticks = (retro_perf_tick_t)tv.tv_sec * 1000000000 + |
| 190 | (retro_perf_tick_t)tv.tv_nsec; |
| 191 | |
| 192 | #elif defined(__GNUC__) && defined(__i386__) || defined(__i486__) || defined(__i686__) || defined(_M_X64) || defined(_M_AMD64) |
| 193 | __asm__ volatile ("rdtsc" : "=A" (time_ticks)); |
| 194 | #elif defined(__GNUC__) && defined(__x86_64__) || defined(_M_IX86) |
| 195 | unsigned a, d; |
| 196 | __asm__ volatile ("rdtsc" : "=a" (a), "=d" (d)); |
| 197 | time_ticks = (retro_perf_tick_t)a | ((retro_perf_tick_t)d << 32); |
| 198 | #elif defined(__ARM_ARCH_6__) |
| 199 | __asm__ volatile( "mrc p15, 0, %0, c9, c13, 0" : "=r"(time_ticks) ); |
| 200 | #elif defined(__aarch64__) |
| 201 | __asm__ volatile( "mrs %0, cntvct_el0" : "=r"(time_ticks) ); |
| 202 | #elif defined(PSP) || defined(VITA) |
| 203 | time_ticks = sceKernelGetSystemTimeWide(); |
| 204 | #elif defined(ORBIS) |
| 205 | sceRtcGetCurrentTick((SceRtcTick*)&time_ticks); |
| 206 | #elif defined(PS2) |
| 207 | time_ticks = ps2_clock(); |
| 208 | #elif defined(_3DS) |
| 209 | time_ticks = svcGetSystemTick(); |
| 210 | #elif defined(WIIU) |
| 211 | time_ticks = OSGetSystemTime(); |
| 212 | #elif defined(HAVE_LIBNX) |
| 213 | time_ticks = armGetSystemTick(); |
| 214 | #elif defined(EMSCRIPTEN) |
| 215 | time_ticks = emscripten_get_now() * 1000; |
| 216 | #endif |
| 217 | |
| 218 | return time_ticks; |
| 219 | } |
| 220 | |
| 221 | /** |
| 222 | * cpu_features_get_time_usec: |
| 223 | * |
| 224 | * Gets time in microseconds. |
| 225 | * |
| 226 | * @return Time in microseconds. |
| 227 | **/ |
| 228 | retro_time_t cpu_features_get_time_usec(void) |
| 229 | { |
| 230 | #if defined(_WIN32) |
| 231 | static LARGE_INTEGER freq; |
| 232 | LARGE_INTEGER count; |
| 233 | |
| 234 | /* Frequency is guaranteed to not change. */ |
| 235 | if (!freq.QuadPart && !QueryPerformanceFrequency(&freq)) |
| 236 | return 0; |
| 237 | |
| 238 | if (!QueryPerformanceCounter(&count)) |
| 239 | return 0; |
| 240 | return (count.QuadPart / freq.QuadPart * 1000000) + (count.QuadPart % freq.QuadPart * 1000000 / freq.QuadPart); |
| 241 | #elif defined(__PSL1GHT__) |
| 242 | return sysGetSystemTime(); |
| 243 | #elif !defined(__PSL1GHT__) && defined(__PS3__) |
| 244 | return sys_time_get_system_time(); |
| 245 | #elif defined(GEKKO) |
| 246 | return ticks_to_microsecs(gettime()); |
| 247 | #elif defined(WIIU) |
| 248 | return ticks_to_us(OSGetSystemTime()); |
| 249 | #elif defined(SWITCH) || defined(HAVE_LIBNX) |
| 250 | return (svcGetSystemTick() * 10) / 192; |
| 251 | #elif defined(_3DS) |
| 252 | return osGetTime() * 1000; |
| 253 | #elif defined(_POSIX_MONOTONIC_CLOCK) || defined(__QNX__) || defined(ANDROID) || defined(__MACH__) |
| 254 | struct timespec tv; |
| 255 | if (ra_clock_gettime(CLOCK_MONOTONIC, &tv) < 0) |
| 256 | return 0; |
| 257 | return tv.tv_sec * INT64_C(1000000) + (tv.tv_nsec + 500) / 1000; |
| 258 | #elif defined(EMSCRIPTEN) |
| 259 | return emscripten_get_now() * 1000; |
| 260 | #elif defined(PS2) |
| 261 | return ps2_clock() / PS2_CLOCKS_PER_MSEC * 1000; |
| 262 | #elif defined(VITA) || defined(PSP) |
| 263 | return sceKernelGetSystemTimeWide(); |
| 264 | #elif defined(DJGPP) |
| 265 | return uclock() * 1000000LL / UCLOCKS_PER_SEC; |
| 266 | #elif defined(ORBIS) |
| 267 | return sceKernelGetProcessTime(); |
| 268 | #else |
| 269 | #error "Your platform does not have a timer function implemented in cpu_features_get_time_usec(). Cannot continue." |
| 270 | #endif |
| 271 | } |
| 272 | |
| 273 | #if defined(__x86_64__) || defined(__i386__) || defined(__i486__) || defined(__i686__) || (defined(_M_X64) && _MSC_VER > 1310) || (defined(_M_IX86) && _MSC_VER > 1310) |
| 274 | #define CPU_X86 |
| 275 | #endif |
| 276 | |
| 277 | #if defined(_MSC_VER) && !defined(_XBOX) |
| 278 | #if (_MSC_VER > 1310) |
| 279 | #include <intrin.h> |
| 280 | #endif |
| 281 | #endif |
| 282 | |
| 283 | #if defined(CPU_X86) && !defined(__MACH__) |
| 284 | void x86_cpuid(int func, int flags[4]) |
| 285 | { |
| 286 | /* On Android, we compile RetroArch with PIC, and we |
| 287 | * are not allowed to clobber the ebx register. */ |
| 288 | #ifdef __x86_64__ |
| 289 | #define REG_b "rbx" |
| 290 | #define REG_S "rsi" |
| 291 | #else |
| 292 | #define REG_b "ebx" |
| 293 | #define REG_S "esi" |
| 294 | #endif |
| 295 | |
| 296 | #if defined(__GNUC__) |
| 297 | __asm__ volatile ( |
| 298 | "mov %%" REG_b ", %%" REG_S "\n" |
| 299 | "cpuid\n" |
| 300 | "xchg %%" REG_b ", %%" REG_S "\n" |
| 301 | : "=a"(flags[0]), "=S"(flags[1]), "=c"(flags[2]), "=d"(flags[3]) |
| 302 | : "a"(func)); |
| 303 | #elif defined(_MSC_VER) |
| 304 | __cpuid(flags, func); |
| 305 | #else |
| 306 | #ifndef NDEBUG |
| 307 | printf("Unknown compiler. Cannot check CPUID with inline assembly.\n"); |
| 308 | #endif |
| 309 | memset(flags, 0, 4 * sizeof(int)); |
| 310 | #endif |
| 311 | } |
| 312 | |
| 313 | /* Only runs on i686 and above. Needs to be conditionally run. */ |
| 314 | static uint64_t xgetbv_x86(uint32_t idx) |
| 315 | { |
| 316 | #if defined(__GNUC__) |
| 317 | uint32_t eax, edx; |
| 318 | __asm__ volatile ( |
| 319 | /* Older GCC versions (Apple's GCC for example) do |
| 320 | * not understand xgetbv instruction. |
| 321 | * Stamp out the machine code directly. |
| 322 | */ |
| 323 | ".byte 0x0f, 0x01, 0xd0\n" |
| 324 | : "=a"(eax), "=d"(edx) : "c"(idx)); |
| 325 | return ((uint64_t)edx << 32) | eax; |
| 326 | #elif _MSC_FULL_VER >= 160040219 |
| 327 | /* Intrinsic only works on 2010 SP1 and above. */ |
| 328 | return _xgetbv(idx); |
| 329 | #else |
| 330 | #ifndef NDEBUG |
| 331 | printf("Unknown compiler. Cannot check xgetbv bits.\n"); |
| 332 | #endif |
| 333 | return 0; |
| 334 | #endif |
| 335 | } |
| 336 | #endif |
| 337 | |
| 338 | #if defined(__ARM_NEON__) |
| 339 | #if defined(__arm__) |
| 340 | static void arm_enable_runfast_mode(void) |
| 341 | { |
| 342 | /* RunFast mode. Enables flush-to-zero and some |
| 343 | * floating point optimizations. */ |
| 344 | static const unsigned x = 0x04086060; |
| 345 | static const unsigned y = 0x03000000; |
| 346 | int r; |
| 347 | __asm__ volatile( |
| 348 | "fmrx %0, fpscr \n\t" /* r0 = FPSCR */ |
| 349 | "and %0, %0, %1 \n\t" /* r0 = r0 & 0x04086060 */ |
| 350 | "orr %0, %0, %2 \n\t" /* r0 = r0 | 0x03000000 */ |
| 351 | "fmxr fpscr, %0 \n\t" /* FPSCR = r0 */ |
| 352 | : "=r"(r) |
| 353 | : "r"(x), "r"(y) |
| 354 | ); |
| 355 | } |
| 356 | #endif |
| 357 | #endif |
| 358 | |
| 359 | #if defined(__linux__) && !defined(CPU_X86) |
| 360 | static unsigned char check_arm_cpu_feature(const char* feature) |
| 361 | { |
| 362 | char line[1024]; |
| 363 | unsigned char status = 0; |
| 364 | RFILE *fp = filestream_open("/proc/cpuinfo", |
| 365 | RETRO_VFS_FILE_ACCESS_READ, |
| 366 | RETRO_VFS_FILE_ACCESS_HINT_NONE); |
| 367 | |
| 368 | if (!fp) |
| 369 | return 0; |
| 370 | |
| 371 | while (filestream_gets(fp, line, sizeof(line))) |
| 372 | { |
| 373 | if (strncmp(line, "Features\t: ", 11)) |
| 374 | continue; |
| 375 | |
| 376 | if (strstr(line + 11, feature)) |
| 377 | status = 1; |
| 378 | |
| 379 | break; |
| 380 | } |
| 381 | |
| 382 | filestream_close(fp); |
| 383 | |
| 384 | return status; |
| 385 | } |
| 386 | |
| 387 | #if !defined(_SC_NPROCESSORS_ONLN) |
| 388 | /** |
| 389 | * parse_decimal: |
| 390 | * |
| 391 | * Parse an decimal integer starting from 'input', but not going further |
| 392 | * than 'limit'. Return the value into '*result'. |
| 393 | * |
| 394 | * NOTE: Does not skip over leading spaces, or deal with sign characters. |
| 395 | * NOTE: Ignores overflows. |
| 396 | * |
| 397 | * The function returns NULL in case of error (bad format), or the new |
| 398 | * position after the decimal number in case of success (which will always |
| 399 | * be <= 'limit'). |
| 400 | * |
| 401 | * Leaf function. |
| 402 | **/ |
| 403 | static const char *parse_decimal(const char* input, |
| 404 | const char* limit, int* result) |
| 405 | { |
| 406 | const char* p = input; |
| 407 | int val = 0; |
| 408 | |
| 409 | while (p < limit) |
| 410 | { |
| 411 | int d = (*p - '0'); |
| 412 | if ((unsigned)d >= 10U) |
| 413 | break; |
| 414 | val = val*10 + d; |
| 415 | p++; |
| 416 | } |
| 417 | if (p == input) |
| 418 | return NULL; |
| 419 | |
| 420 | *result = val; |
| 421 | return p; |
| 422 | } |
| 423 | |
| 424 | /** |
| 425 | * cpulist_parse: |
| 426 | * Parse a textual list of cpus and store the result inside a CpuList object. |
| 427 | * Input format is the following: |
| 428 | * - comma-separated list of items (no spaces) |
| 429 | * - each item is either a single decimal number (cpu index), or a range made |
| 430 | * of two numbers separated by a single dash (-). Ranges are inclusive. |
| 431 | * |
| 432 | * Examples: 0 |
| 433 | * 2,4-127,128-143 |
| 434 | * 0-1 |
| 435 | **/ |
| 436 | static void cpulist_parse(CpuList* list, char **buf, ssize_t length) |
| 437 | { |
| 438 | const char* p = (const char*)buf; |
| 439 | const char* end = p + length; |
| 440 | |
| 441 | /* NOTE: the input line coming from sysfs typically contains a |
| 442 | * trailing newline, so take care of it in the code below |
| 443 | */ |
| 444 | while (p < end && *p != '\n') |
| 445 | { |
| 446 | int val, start_value, end_value; |
| 447 | /* Find the end of current item, and put it into 'q' */ |
| 448 | const char *q = (const char*)memchr(p, ',', end-p); |
| 449 | |
| 450 | if (!q) |
| 451 | q = end; |
| 452 | |
| 453 | /* Get first value */ |
| 454 | if (!(p = parse_decimal(p, q, &start_value))) |
| 455 | return; |
| 456 | |
| 457 | end_value = start_value; |
| 458 | |
| 459 | /* If we're not at the end of the item, expect a dash and |
| 460 | * and integer; extract end value. |
| 461 | */ |
| 462 | if (p < q && *p == '-') |
| 463 | { |
| 464 | if (!(p = parse_decimal(p+1, q, &end_value))) |
| 465 | return; |
| 466 | } |
| 467 | |
| 468 | /* Set bits CPU list bits */ |
| 469 | for (val = start_value; val <= end_value; val++) |
| 470 | { |
| 471 | if ((unsigned)val < 32) |
| 472 | list->mask |= (uint32_t)(UINT32_C(1) << val); |
| 473 | } |
| 474 | |
| 475 | /* Jump to next item */ |
| 476 | p = q; |
| 477 | if (p < end) |
| 478 | p++; |
| 479 | } |
| 480 | } |
| 481 | |
| 482 | /** |
| 483 | * cpulist_read_from: |
| 484 | * |
| 485 | * Read a CPU list from one sysfs file |
| 486 | **/ |
| 487 | static void cpulist_read_from(CpuList* list, const char* filename) |
| 488 | { |
| 489 | ssize_t length; |
| 490 | char *buf = NULL; |
| 491 | |
| 492 | list->mask = 0; |
| 493 | |
| 494 | if (filestream_read_file(filename, (void**)&buf, &length) != 1) |
| 495 | return; |
| 496 | |
| 497 | cpulist_parse(list, &buf, length); |
| 498 | if (buf) |
| 499 | free(buf); |
| 500 | buf = NULL; |
| 501 | } |
| 502 | #endif |
| 503 | |
| 504 | #endif |
| 505 | |
| 506 | /** |
| 507 | * cpu_features_get_core_amount: |
| 508 | * |
| 509 | * Gets the amount of available CPU cores. |
| 510 | * |
| 511 | * @return Amount of CPU cores available. |
| 512 | **/ |
| 513 | unsigned cpu_features_get_core_amount(void) |
| 514 | { |
| 515 | #if defined(_WIN32) && !defined(_XBOX) |
| 516 | /* Win32 */ |
| 517 | SYSTEM_INFO sysinfo; |
| 518 | #if defined(__WINRT__) || defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP |
| 519 | GetNativeSystemInfo(&sysinfo); |
| 520 | #else |
| 521 | GetSystemInfo(&sysinfo); |
| 522 | #endif |
| 523 | return sysinfo.dwNumberOfProcessors; |
| 524 | #elif defined(GEKKO) |
| 525 | return 1; |
| 526 | #elif defined(PSP) || defined(PS2) |
| 527 | return 1; |
| 528 | #elif defined(__PSL1GHT__) || !defined(__PSL1GHT__) && defined(__PS3__) |
| 529 | return 1; /* Only one PPU, SPUs don't really count */ |
| 530 | #elif defined(VITA) |
| 531 | return 4; |
| 532 | #elif defined(HAVE_LIBNX) || defined(SWITCH) |
| 533 | return 4; |
| 534 | #elif defined(_3DS) |
| 535 | u8 device_model = 0xFF; |
| 536 | CFGU_GetSystemModel(&device_model);/*(0 = O3DS, 1 = O3DSXL, 2 = N3DS, 3 = 2DS, 4 = N3DSXL, 5 = N2DSXL)*/ |
| 537 | switch (device_model) |
| 538 | { |
| 539 | case 0: |
| 540 | case 1: |
| 541 | case 3: |
| 542 | /*Old 3/2DS*/ |
| 543 | return 2; |
| 544 | |
| 545 | case 2: |
| 546 | case 4: |
| 547 | case 5: |
| 548 | /*New 3/2DS*/ |
| 549 | return 4; |
| 550 | |
| 551 | default: |
| 552 | /*Unknown Device Or Check Failed*/ |
| 553 | break; |
| 554 | } |
| 555 | return 1; |
| 556 | #elif defined(WIIU) |
| 557 | return 3; |
| 558 | #elif defined(_SC_NPROCESSORS_ONLN) |
| 559 | /* Linux, most UNIX-likes. */ |
| 560 | long ret = sysconf(_SC_NPROCESSORS_ONLN); |
| 561 | if (ret <= 0) |
| 562 | return (unsigned)1; |
| 563 | return (unsigned)ret; |
| 564 | #elif defined(BSD) || defined(__APPLE__) |
| 565 | /* BSD */ |
| 566 | /* Copypasta from stackoverflow, dunno if it works. */ |
| 567 | int num_cpu = 0; |
| 568 | int mib[4]; |
| 569 | size_t len = sizeof(num_cpu); |
| 570 | |
| 571 | mib[0] = CTL_HW; |
| 572 | mib[1] = HW_AVAILCPU; |
| 573 | sysctl(mib, 2, &num_cpu, &len, NULL, 0); |
| 574 | if (num_cpu < 1) |
| 575 | { |
| 576 | mib[1] = HW_NCPU; |
| 577 | sysctl(mib, 2, &num_cpu, &len, NULL, 0); |
| 578 | if (num_cpu < 1) |
| 579 | num_cpu = 1; |
| 580 | } |
| 581 | return num_cpu; |
| 582 | #elif defined(__linux__) |
| 583 | CpuList cpus_present[1]; |
| 584 | CpuList cpus_possible[1]; |
| 585 | int amount = 0; |
| 586 | |
| 587 | cpulist_read_from(cpus_present, "/sys/devices/system/cpu/present"); |
| 588 | cpulist_read_from(cpus_possible, "/sys/devices/system/cpu/possible"); |
| 589 | |
| 590 | /* Compute the intersection of both sets to get the actual number of |
| 591 | * CPU cores that can be used on this device by the kernel. |
| 592 | */ |
| 593 | cpus_present->mask &= cpus_possible->mask; |
| 594 | amount = __builtin_popcount(cpus_present->mask); |
| 595 | |
| 596 | if (amount == 0) |
| 597 | return 1; |
| 598 | return amount; |
| 599 | #elif defined(_XBOX360) |
| 600 | return 3; |
| 601 | #else |
| 602 | /* No idea, assume single core. */ |
| 603 | return 1; |
| 604 | #endif |
| 605 | } |
| 606 | |
| 607 | /* According to http://en.wikipedia.org/wiki/CPUID */ |
| 608 | #define VENDOR_INTEL_b 0x756e6547 |
| 609 | #define VENDOR_INTEL_c 0x6c65746e |
| 610 | #define VENDOR_INTEL_d 0x49656e69 |
| 611 | |
| 612 | /** |
| 613 | * cpu_features_get: |
| 614 | * |
| 615 | * Gets CPU features.. |
| 616 | * |
| 617 | * @return Bitmask of all CPU features available. |
| 618 | **/ |
| 619 | uint64_t cpu_features_get(void) |
| 620 | { |
| 621 | uint64_t cpu = 0; |
| 622 | #if defined(CPU_X86) && !defined(__MACH__) |
| 623 | int vendor_is_intel = 0; |
| 624 | const int avx_flags = (1 << 27) | (1 << 28); |
| 625 | #endif |
| 626 | #if defined(__MACH__) |
| 627 | size_t len = sizeof(size_t); |
| 628 | |
| 629 | if (sysctlbyname("hw.optional.floatingpoint", NULL, &len, NULL, 0) == 0) |
| 630 | cpu |= RETRO_SIMD_CMOV; |
| 631 | |
| 632 | #if defined(CPU_X86) |
| 633 | len = sizeof(size_t); |
| 634 | if (sysctlbyname("hw.optional.mmx", NULL, &len, NULL, 0) == 0) |
| 635 | cpu |= RETRO_SIMD_MMX | RETRO_SIMD_MMXEXT; |
| 636 | |
| 637 | len = sizeof(size_t); |
| 638 | if (sysctlbyname("hw.optional.sse", NULL, &len, NULL, 0) == 0) |
| 639 | cpu |= RETRO_SIMD_SSE; |
| 640 | |
| 641 | len = sizeof(size_t); |
| 642 | if (sysctlbyname("hw.optional.sse2", NULL, &len, NULL, 0) == 0) |
| 643 | cpu |= RETRO_SIMD_SSE2; |
| 644 | |
| 645 | len = sizeof(size_t); |
| 646 | if (sysctlbyname("hw.optional.sse3", NULL, &len, NULL, 0) == 0) |
| 647 | cpu |= RETRO_SIMD_SSE3; |
| 648 | |
| 649 | len = sizeof(size_t); |
| 650 | if (sysctlbyname("hw.optional.supplementalsse3", NULL, &len, NULL, 0) == 0) |
| 651 | cpu |= RETRO_SIMD_SSSE3; |
| 652 | |
| 653 | len = sizeof(size_t); |
| 654 | if (sysctlbyname("hw.optional.sse4_1", NULL, &len, NULL, 0) == 0) |
| 655 | cpu |= RETRO_SIMD_SSE4; |
| 656 | |
| 657 | len = sizeof(size_t); |
| 658 | if (sysctlbyname("hw.optional.sse4_2", NULL, &len, NULL, 0) == 0) |
| 659 | cpu |= RETRO_SIMD_SSE42; |
| 660 | |
| 661 | len = sizeof(size_t); |
| 662 | if (sysctlbyname("hw.optional.aes", NULL, &len, NULL, 0) == 0) |
| 663 | cpu |= RETRO_SIMD_AES; |
| 664 | |
| 665 | len = sizeof(size_t); |
| 666 | if (sysctlbyname("hw.optional.avx1_0", NULL, &len, NULL, 0) == 0) |
| 667 | cpu |= RETRO_SIMD_AVX; |
| 668 | |
| 669 | len = sizeof(size_t); |
| 670 | if (sysctlbyname("hw.optional.avx2_0", NULL, &len, NULL, 0) == 0) |
| 671 | cpu |= RETRO_SIMD_AVX2; |
| 672 | |
| 673 | len = sizeof(size_t); |
| 674 | if (sysctlbyname("hw.optional.altivec", NULL, &len, NULL, 0) == 0) |
| 675 | cpu |= RETRO_SIMD_VMX; |
| 676 | |
| 677 | #else |
| 678 | len = sizeof(size_t); |
| 679 | if (sysctlbyname("hw.optional.neon", NULL, &len, NULL, 0) == 0) |
| 680 | cpu |= RETRO_SIMD_NEON; |
| 681 | |
| 682 | len = sizeof(size_t); |
| 683 | if (sysctlbyname("hw.optional.neon_fp16", NULL, &len, NULL, 0) == 0) |
| 684 | cpu |= RETRO_SIMD_VFPV3; |
| 685 | |
| 686 | len = sizeof(size_t); |
| 687 | if (sysctlbyname("hw.optional.neon_hpfp", NULL, &len, NULL, 0) == 0) |
| 688 | cpu |= RETRO_SIMD_VFPV4; |
| 689 | #endif |
| 690 | #elif defined(_XBOX1) |
| 691 | cpu |= RETRO_SIMD_MMX | RETRO_SIMD_SSE | RETRO_SIMD_MMXEXT; |
| 692 | #elif defined(CPU_X86) |
| 693 | unsigned max_flag = 0; |
| 694 | int flags[4]; |
| 695 | int vendor_shuffle[3]; |
| 696 | char vendor[13]; |
| 697 | x86_cpuid(0, flags); |
| 698 | vendor_shuffle[0] = flags[1]; |
| 699 | vendor_shuffle[1] = flags[3]; |
| 700 | vendor_shuffle[2] = flags[2]; |
| 701 | |
| 702 | vendor[0] = '\0'; |
| 703 | memcpy(vendor, vendor_shuffle, sizeof(vendor_shuffle)); |
| 704 | |
| 705 | /* printf("[CPUID]: Vendor: %s\n", vendor); */ |
| 706 | |
| 707 | vendor_is_intel = ( |
| 708 | flags[1] == VENDOR_INTEL_b && |
| 709 | flags[2] == VENDOR_INTEL_c && |
| 710 | flags[3] == VENDOR_INTEL_d); |
| 711 | |
| 712 | max_flag = flags[0]; |
| 713 | if (max_flag < 1) /* Does CPUID not support func = 1? (unlikely ...) */ |
| 714 | return 0; |
| 715 | |
| 716 | x86_cpuid(1, flags); |
| 717 | |
| 718 | if (flags[3] & (1 << 15)) |
| 719 | cpu |= RETRO_SIMD_CMOV; |
| 720 | |
| 721 | if (flags[3] & (1 << 23)) |
| 722 | cpu |= RETRO_SIMD_MMX; |
| 723 | |
| 724 | /* SSE also implies MMXEXT (according to FFmpeg source). */ |
| 725 | if (flags[3] & (1 << 25)) |
| 726 | cpu |= RETRO_SIMD_SSE | RETRO_SIMD_MMXEXT; |
| 727 | |
| 728 | if (flags[3] & (1 << 26)) |
| 729 | cpu |= RETRO_SIMD_SSE2; |
| 730 | |
| 731 | if (flags[2] & (1 << 0)) |
| 732 | cpu |= RETRO_SIMD_SSE3; |
| 733 | |
| 734 | if (flags[2] & (1 << 9)) |
| 735 | cpu |= RETRO_SIMD_SSSE3; |
| 736 | |
| 737 | if (flags[2] & (1 << 19)) |
| 738 | cpu |= RETRO_SIMD_SSE4; |
| 739 | |
| 740 | if (flags[2] & (1 << 20)) |
| 741 | cpu |= RETRO_SIMD_SSE42; |
| 742 | |
| 743 | if ((flags[2] & (1 << 23))) |
| 744 | cpu |= RETRO_SIMD_POPCNT; |
| 745 | |
| 746 | if (vendor_is_intel && (flags[2] & (1 << 22))) |
| 747 | cpu |= RETRO_SIMD_MOVBE; |
| 748 | |
| 749 | if (flags[2] & (1 << 25)) |
| 750 | cpu |= RETRO_SIMD_AES; |
| 751 | |
| 752 | /* Must only perform xgetbv check if we have |
| 753 | * AVX CPU support (guaranteed to have at least i686). */ |
| 754 | if (((flags[2] & avx_flags) == avx_flags) |
| 755 | && ((xgetbv_x86(0) & 0x6) == 0x6)) |
| 756 | cpu |= RETRO_SIMD_AVX; |
| 757 | |
| 758 | if (max_flag >= 7) |
| 759 | { |
| 760 | x86_cpuid(7, flags); |
| 761 | if (flags[1] & (1 << 5)) |
| 762 | cpu |= RETRO_SIMD_AVX2; |
| 763 | } |
| 764 | |
| 765 | x86_cpuid(0x80000000, flags); |
| 766 | max_flag = flags[0]; |
| 767 | if (max_flag >= 0x80000001u) |
| 768 | { |
| 769 | x86_cpuid(0x80000001, flags); |
| 770 | if (flags[3] & (1 << 23)) |
| 771 | cpu |= RETRO_SIMD_MMX; |
| 772 | if (flags[3] & (1 << 22)) |
| 773 | cpu |= RETRO_SIMD_MMXEXT; |
| 774 | } |
| 775 | #elif defined(__linux__) |
| 776 | if (check_arm_cpu_feature("neon")) |
| 777 | { |
| 778 | cpu |= RETRO_SIMD_NEON; |
| 779 | #if defined(__ARM_NEON__) && defined(__arm__) |
| 780 | arm_enable_runfast_mode(); |
| 781 | #endif |
| 782 | } |
| 783 | |
| 784 | if (check_arm_cpu_feature("vfpv3")) |
| 785 | cpu |= RETRO_SIMD_VFPV3; |
| 786 | |
| 787 | if (check_arm_cpu_feature("vfpv4")) |
| 788 | cpu |= RETRO_SIMD_VFPV4; |
| 789 | |
| 790 | if (check_arm_cpu_feature("asimd")) |
| 791 | { |
| 792 | cpu |= RETRO_SIMD_ASIMD; |
| 793 | #ifdef __ARM_NEON__ |
| 794 | cpu |= RETRO_SIMD_NEON; |
| 795 | #if defined(__arm__) |
| 796 | arm_enable_runfast_mode(); |
| 797 | #endif |
| 798 | #endif |
| 799 | } |
| 800 | |
| 801 | #if 0 |
| 802 | check_arm_cpu_feature("swp"); |
| 803 | check_arm_cpu_feature("half"); |
| 804 | check_arm_cpu_feature("thumb"); |
| 805 | check_arm_cpu_feature("fastmult"); |
| 806 | check_arm_cpu_feature("vfp"); |
| 807 | check_arm_cpu_feature("edsp"); |
| 808 | check_arm_cpu_feature("thumbee"); |
| 809 | check_arm_cpu_feature("tls"); |
| 810 | check_arm_cpu_feature("idiva"); |
| 811 | check_arm_cpu_feature("idivt"); |
| 812 | #endif |
| 813 | |
| 814 | #elif defined(__ARM_NEON__) |
| 815 | cpu |= RETRO_SIMD_NEON; |
| 816 | #if defined(__arm__) |
| 817 | arm_enable_runfast_mode(); |
| 818 | #endif |
| 819 | #elif defined(__ALTIVEC__) |
| 820 | cpu |= RETRO_SIMD_VMX; |
| 821 | #elif defined(XBOX360) |
| 822 | cpu |= RETRO_SIMD_VMX128; |
| 823 | #elif defined(PSP) || defined(PS2) |
| 824 | cpu |= RETRO_SIMD_VFPU; |
| 825 | #elif defined(GEKKO) |
| 826 | cpu |= RETRO_SIMD_PS; |
| 827 | #endif |
| 828 | |
| 829 | return cpu; |
| 830 | } |
| 831 | |
| 832 | void cpu_features_get_model_name(char *name, int len) |
| 833 | { |
| 834 | #if defined(CPU_X86) && !defined(__MACH__) |
| 835 | union { |
| 836 | int32_t i[4]; |
| 837 | uint32_t u[4]; |
| 838 | uint8_t s[16]; |
| 839 | } flags; |
| 840 | int i, j; |
| 841 | int pos = 0; |
| 842 | bool start = false; |
| 843 | |
| 844 | if (!name) |
| 845 | return; |
| 846 | |
| 847 | x86_cpuid(0x80000000, flags.i); |
| 848 | |
| 849 | /* Check for additional cpuid attributes availability */ |
| 850 | if (flags.u[0] < 0x80000004) |
| 851 | return; |
| 852 | |
| 853 | for (i = 0; i < 3; i++) |
| 854 | { |
| 855 | memset(flags.i, 0, sizeof(flags.i)); |
| 856 | x86_cpuid(0x80000002 + i, flags.i); |
| 857 | |
| 858 | for (j = 0; j < (int)sizeof(flags.s); j++) |
| 859 | { |
| 860 | if (!start && flags.s[j] == ' ') |
| 861 | continue; |
| 862 | else |
| 863 | start = true; |
| 864 | |
| 865 | if (pos == len - 1) |
| 866 | { |
| 867 | /* truncate if we ran out of room */ |
| 868 | name[pos] = '\0'; |
| 869 | goto end; |
| 870 | } |
| 871 | |
| 872 | name[pos++] = flags.s[j]; |
| 873 | } |
| 874 | } |
| 875 | end: |
| 876 | /* terminate our string */ |
| 877 | if (pos < len) |
| 878 | name[pos] = '\0'; |
| 879 | #elif defined(__MACH__) |
| 880 | if (!name) |
| 881 | return; |
| 882 | { |
| 883 | size_t len_size = len; |
| 884 | sysctlbyname("machdep.cpu.brand_string", name, &len_size, NULL, 0); |
| 885 | } |
| 886 | #elif defined(__linux__) |
| 887 | if (!name) |
| 888 | return; |
| 889 | { |
| 890 | char *model_name, line[128]; |
| 891 | RFILE *fp = filestream_open("/proc/cpuinfo", |
| 892 | RETRO_VFS_FILE_ACCESS_READ, |
| 893 | RETRO_VFS_FILE_ACCESS_HINT_NONE); |
| 894 | |
| 895 | if (!fp) |
| 896 | return; |
| 897 | |
| 898 | while (filestream_gets(fp, line, sizeof(line))) |
| 899 | { |
| 900 | if (strncmp(line, "model name", 10)) |
| 901 | continue; |
| 902 | |
| 903 | if ((model_name = strstr(line + 10, ": "))) |
| 904 | { |
| 905 | model_name += 2; |
| 906 | strncpy(name, model_name, len); |
| 907 | name[len - 1] = '\0'; |
| 908 | } |
| 909 | |
| 910 | break; |
| 911 | } |
| 912 | |
| 913 | filestream_close(fp); |
| 914 | } |
| 915 | #else |
| 916 | if (!name) |
| 917 | return; |
| 918 | return; |
| 919 | #endif |
| 920 | } |