henrike@webrtc.org | 0e118e7 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1 | /* |
| 2 | * libjingle |
| 3 | * Copyright 2008 Google Inc. |
| 4 | * |
| 5 | * Redistribution and use in source and binary forms, with or without |
| 6 | * modification, are permitted provided that the following conditions are met: |
| 7 | * |
| 8 | * 1. Redistributions of source code must retain the above copyright notice, |
| 9 | * this list of conditions and the following disclaimer. |
| 10 | * 2. Redistributions in binary form must reproduce the above copyright notice, |
| 11 | * this list of conditions and the following disclaimer in the documentation |
| 12 | * and/or other materials provided with the distribution. |
| 13 | * 3. The name of the author may not be used to endorse or promote products |
| 14 | * derived from this software without specific prior written permission. |
| 15 | * |
| 16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED |
| 17 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| 18 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO |
| 19 | * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 20 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| 21 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; |
| 22 | * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| 23 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| 24 | * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
| 25 | * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 26 | */ |
| 27 | |
| 28 | #include "talk/base/systeminfo.h" |
| 29 | |
| 30 | #if defined(WIN32) |
| 31 | #include <winsock2.h> |
| 32 | #ifndef EXCLUDE_D3D9 |
| 33 | #include <d3d9.h> |
| 34 | #endif |
| 35 | #include <intrin.h> // for __cpuid() |
| 36 | #elif defined(OSX) |
| 37 | #include <ApplicationServices/ApplicationServices.h> |
| 38 | #include <CoreServices/CoreServices.h> |
| 39 | #elif defined(LINUX) || defined(ANDROID) |
| 40 | #include <unistd.h> |
| 41 | #endif |
| 42 | #if defined(OSX) || defined(IOS) |
| 43 | #include <sys/sysctl.h> |
| 44 | #endif |
| 45 | |
| 46 | #if defined(WIN32) |
| 47 | #include "talk/base/scoped_ptr.h" |
| 48 | #include "talk/base/win32.h" |
| 49 | #elif defined(OSX) |
| 50 | #include "talk/base/macconversion.h" |
| 51 | #elif defined(LINUX) || defined(ANDROID) |
| 52 | #include "talk/base/linux.h" |
| 53 | #endif |
| 54 | #include "talk/base/common.h" |
| 55 | #include "talk/base/logging.h" |
| 56 | #include "talk/base/stringutils.h" |
| 57 | |
| 58 | namespace talk_base { |
| 59 | |
| 60 | // See Also: http://msdn.microsoft.com/en-us/library/ms683194(v=vs.85).aspx |
| 61 | #if defined(WIN32) |
| 62 | typedef BOOL (WINAPI *LPFN_GLPI)( |
| 63 | PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, |
| 64 | PDWORD); |
| 65 | |
| 66 | static void GetProcessorInformation(int* physical_cpus, int* cache_size) { |
| 67 | // GetLogicalProcessorInformation() is available on Windows XP SP3 and beyond. |
| 68 | LPFN_GLPI glpi = reinterpret_cast<LPFN_GLPI>(GetProcAddress( |
| 69 | GetModuleHandle(L"kernel32"), |
| 70 | "GetLogicalProcessorInformation")); |
| 71 | if (NULL == glpi) { |
| 72 | return; |
| 73 | } |
| 74 | // Determine buffer size, allocate and get processor information. |
| 75 | // Size can change between calls (unlikely), so a loop is done. |
| 76 | DWORD return_length = 0; |
wu@webrtc.org | 5c9dd59 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 77 | scoped_ptr<SYSTEM_LOGICAL_PROCESSOR_INFORMATION[]> infos; |
henrike@webrtc.org | 0e118e7 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 78 | while (!glpi(infos.get(), &return_length)) { |
| 79 | if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) { |
| 80 | infos.reset(new SYSTEM_LOGICAL_PROCESSOR_INFORMATION[ |
| 81 | return_length / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION)]); |
| 82 | } else { |
| 83 | return; |
| 84 | } |
| 85 | } |
| 86 | *physical_cpus = 0; |
| 87 | *cache_size = 0; |
| 88 | for (size_t i = 0; |
| 89 | i < return_length / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION); ++i) { |
| 90 | if (infos[i].Relationship == RelationProcessorCore) { |
| 91 | ++*physical_cpus; |
| 92 | } else if (infos[i].Relationship == RelationCache) { |
| 93 | int next_cache_size = static_cast<int>(infos[i].Cache.Size); |
| 94 | if (next_cache_size >= *cache_size) { |
| 95 | *cache_size = next_cache_size; |
| 96 | } |
| 97 | } |
| 98 | } |
| 99 | return; |
| 100 | } |
| 101 | #else |
| 102 | // TODO(fbarchard): Use gcc 4.4 provided cpuid intrinsic |
| 103 | // 32 bit fpic requires ebx be preserved |
| 104 | #if (defined(__pic__) || defined(__APPLE__)) && defined(__i386__) |
| 105 | static inline void __cpuid(int cpu_info[4], int info_type) { |
| 106 | __asm__ volatile ( // NOLINT |
| 107 | "mov %%ebx, %%edi\n" |
| 108 | "cpuid\n" |
| 109 | "xchg %%edi, %%ebx\n" |
| 110 | : "=a"(cpu_info[0]), "=D"(cpu_info[1]), "=c"(cpu_info[2]), "=d"(cpu_info[3]) |
| 111 | : "a"(info_type) |
| 112 | ); // NOLINT |
| 113 | } |
| 114 | #elif defined(__i386__) || defined(__x86_64__) |
| 115 | static inline void __cpuid(int cpu_info[4], int info_type) { |
| 116 | __asm__ volatile ( // NOLINT |
| 117 | "cpuid\n" |
| 118 | : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]), "=d"(cpu_info[3]) |
| 119 | : "a"(info_type) |
| 120 | ); // NOLINT |
| 121 | } |
| 122 | #endif |
| 123 | #endif // WIN32 |
| 124 | |
| 125 | // Note(fbarchard): |
| 126 | // Family and model are extended family and extended model. 8 bits each. |
| 127 | SystemInfo::SystemInfo() |
| 128 | : physical_cpus_(1), logical_cpus_(1), cache_size_(0), |
| 129 | cpu_family_(0), cpu_model_(0), cpu_stepping_(0), |
| 130 | cpu_speed_(0), memory_(0) { |
| 131 | // Initialize the basic information. |
| 132 | #if defined(__arm__) || defined(_M_ARM) |
| 133 | cpu_arch_ = SI_ARCH_ARM; |
| 134 | #elif defined(__x86_64__) || defined(_M_X64) |
| 135 | cpu_arch_ = SI_ARCH_X64; |
| 136 | #elif defined(__i386__) || defined(_M_IX86) |
| 137 | cpu_arch_ = SI_ARCH_X86; |
| 138 | #else |
| 139 | cpu_arch_ = SI_ARCH_UNKNOWN; |
| 140 | #endif |
| 141 | |
| 142 | #if defined(WIN32) |
| 143 | SYSTEM_INFO si; |
| 144 | GetSystemInfo(&si); |
| 145 | logical_cpus_ = si.dwNumberOfProcessors; |
| 146 | GetProcessorInformation(&physical_cpus_, &cache_size_); |
| 147 | if (physical_cpus_ <= 0) { |
| 148 | physical_cpus_ = logical_cpus_; |
| 149 | } |
| 150 | cpu_family_ = si.wProcessorLevel; |
| 151 | cpu_model_ = si.wProcessorRevision >> 8; |
| 152 | cpu_stepping_ = si.wProcessorRevision & 0xFF; |
| 153 | #elif defined(OSX) || defined(IOS) |
| 154 | uint32_t sysctl_value; |
| 155 | size_t length = sizeof(sysctl_value); |
| 156 | if (!sysctlbyname("hw.physicalcpu_max", &sysctl_value, &length, NULL, 0)) { |
| 157 | physical_cpus_ = static_cast<int>(sysctl_value); |
| 158 | } |
| 159 | length = sizeof(sysctl_value); |
| 160 | if (!sysctlbyname("hw.logicalcpu_max", &sysctl_value, &length, NULL, 0)) { |
| 161 | logical_cpus_ = static_cast<int>(sysctl_value); |
| 162 | } |
| 163 | uint64_t sysctl_value64; |
| 164 | length = sizeof(sysctl_value64); |
| 165 | if (!sysctlbyname("hw.l3cachesize", &sysctl_value64, &length, NULL, 0)) { |
| 166 | cache_size_ = static_cast<int>(sysctl_value64); |
| 167 | } |
| 168 | if (!cache_size_) { |
| 169 | length = sizeof(sysctl_value64); |
| 170 | if (!sysctlbyname("hw.l2cachesize", &sysctl_value64, &length, NULL, 0)) { |
| 171 | cache_size_ = static_cast<int>(sysctl_value64); |
| 172 | } |
| 173 | } |
| 174 | length = sizeof(sysctl_value); |
| 175 | if (!sysctlbyname("machdep.cpu.family", &sysctl_value, &length, NULL, 0)) { |
| 176 | cpu_family_ = static_cast<int>(sysctl_value); |
| 177 | } |
| 178 | length = sizeof(sysctl_value); |
| 179 | if (!sysctlbyname("machdep.cpu.model", &sysctl_value, &length, NULL, 0)) { |
| 180 | cpu_model_ = static_cast<int>(sysctl_value); |
| 181 | } |
| 182 | length = sizeof(sysctl_value); |
| 183 | if (!sysctlbyname("machdep.cpu.stepping", &sysctl_value, &length, NULL, 0)) { |
| 184 | cpu_stepping_ = static_cast<int>(sysctl_value); |
| 185 | } |
wu@webrtc.org | 5c9dd59 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 186 | #elif defined(__native_client__) |
| 187 | // TODO(ryanpetrie): Implement this via PPAPI when it's available. |
henrike@webrtc.org | 0e118e7 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 188 | #else // LINUX || ANDROID |
| 189 | ProcCpuInfo proc_info; |
| 190 | if (proc_info.LoadFromSystem()) { |
| 191 | proc_info.GetNumCpus(&logical_cpus_); |
| 192 | proc_info.GetNumPhysicalCpus(&physical_cpus_); |
| 193 | proc_info.GetCpuFamily(&cpu_family_); |
| 194 | #if defined(CPU_X86) |
| 195 | // These values only apply to x86 systems. |
| 196 | proc_info.GetSectionIntValue(0, "model", &cpu_model_); |
| 197 | proc_info.GetSectionIntValue(0, "stepping", &cpu_stepping_); |
| 198 | proc_info.GetSectionIntValue(0, "cpu MHz", &cpu_speed_); |
| 199 | proc_info.GetSectionIntValue(0, "cache size", &cache_size_); |
| 200 | cache_size_ *= 1024; |
| 201 | #endif |
| 202 | } |
| 203 | // ProcCpuInfo reads cpu speed from "cpu MHz" under /proc/cpuinfo. |
| 204 | // But that number is a moving target which can change on-the-fly according to |
| 205 | // many factors including system workload. |
| 206 | // See /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_governors. |
| 207 | // The one in /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq is more |
| 208 | // accurate. We use it as our cpu speed when it is available. |
| 209 | // cpuinfo_max_freq is measured in KHz and requires conversion to MHz. |
| 210 | int max_freq = talk_base::ReadCpuMaxFreq(); |
| 211 | if (max_freq > 0) { |
| 212 | cpu_speed_ = max_freq / 1000; |
| 213 | } |
| 214 | #endif |
| 215 | // For L2 CacheSize see also |
| 216 | // http://www.flounder.com/cpuid_explorer2.htm#CPUID(0x800000006) |
| 217 | #ifdef CPU_X86 |
| 218 | if (cache_size_ == 0) { |
| 219 | int cpu_info[4]; |
| 220 | __cpuid(cpu_info, 0x80000000); // query maximum extended cpuid function. |
| 221 | if (static_cast<uint32>(cpu_info[0]) >= 0x80000006) { |
| 222 | __cpuid(cpu_info, 0x80000006); |
| 223 | cache_size_ = (cpu_info[2] >> 16) * 1024; |
| 224 | } |
| 225 | } |
| 226 | #endif |
| 227 | } |
| 228 | |
| 229 | // Return the number of cpu threads available to the system. |
| 230 | int SystemInfo::GetMaxCpus() { |
| 231 | return logical_cpus_; |
| 232 | } |
| 233 | |
| 234 | // Return the number of cpu cores available to the system. |
| 235 | int SystemInfo::GetMaxPhysicalCpus() { |
| 236 | return physical_cpus_; |
| 237 | } |
| 238 | |
| 239 | // Return the number of cpus available to the process. Since affinity can be |
| 240 | // changed on the fly, do not cache this value. |
| 241 | // Can be affected by heat. |
| 242 | int SystemInfo::GetCurCpus() { |
| 243 | int cur_cpus; |
| 244 | #if defined(WIN32) |
| 245 | DWORD_PTR process_mask, system_mask; |
| 246 | ::GetProcessAffinityMask(::GetCurrentProcess(), &process_mask, &system_mask); |
| 247 | for (cur_cpus = 0; process_mask; ++cur_cpus) { |
| 248 | // Sparse-ones algorithm. There are slightly faster methods out there but |
| 249 | // they are unintuitive and won't make a difference on a single dword. |
| 250 | process_mask &= (process_mask - 1); |
| 251 | } |
| 252 | #elif defined(OSX) || defined(IOS) |
| 253 | uint32_t sysctl_value; |
| 254 | size_t length = sizeof(sysctl_value); |
| 255 | int error = sysctlbyname("hw.ncpu", &sysctl_value, &length, NULL, 0); |
| 256 | cur_cpus = !error ? static_cast<int>(sysctl_value) : 1; |
| 257 | #else |
| 258 | // Linux, Solaris, ANDROID |
| 259 | cur_cpus = static_cast<int>(sysconf(_SC_NPROCESSORS_ONLN)); |
| 260 | #endif |
| 261 | return cur_cpus; |
| 262 | } |
| 263 | |
| 264 | // Return the type of this CPU. |
| 265 | SystemInfo::Architecture SystemInfo::GetCpuArchitecture() { |
| 266 | return cpu_arch_; |
| 267 | } |
| 268 | |
| 269 | // Returns the vendor string from the cpu, e.g. "GenuineIntel", "AuthenticAMD". |
| 270 | // See "Intel Processor Identification and the CPUID Instruction" |
| 271 | // (Intel document number: 241618) |
| 272 | std::string SystemInfo::GetCpuVendor() { |
| 273 | if (cpu_vendor_.empty()) { |
| 274 | #if defined(CPU_X86) |
| 275 | int cpu_info[4]; |
| 276 | __cpuid(cpu_info, 0); |
| 277 | cpu_info[0] = cpu_info[1]; // Reorder output |
| 278 | cpu_info[1] = cpu_info[3]; |
| 279 | cpu_info[2] = cpu_info[2]; |
| 280 | cpu_info[3] = 0; |
| 281 | cpu_vendor_ = std::string(reinterpret_cast<char*>(&cpu_info[0])); |
| 282 | #elif defined(CPU_ARM) |
| 283 | cpu_vendor_ = std::string("ARM"); |
| 284 | #else |
| 285 | cpu_vendor_ = std::string("Undefined"); |
| 286 | #endif |
| 287 | } |
| 288 | return cpu_vendor_; |
| 289 | } |
| 290 | |
| 291 | int SystemInfo::GetCpuCacheSize() { |
| 292 | return cache_size_; |
| 293 | } |
| 294 | |
| 295 | // Return the "family" of this CPU. |
| 296 | int SystemInfo::GetCpuFamily() { |
| 297 | return cpu_family_; |
| 298 | } |
| 299 | |
| 300 | // Return the "model" of this CPU. |
| 301 | int SystemInfo::GetCpuModel() { |
| 302 | return cpu_model_; |
| 303 | } |
| 304 | |
| 305 | // Return the "stepping" of this CPU. |
| 306 | int SystemInfo::GetCpuStepping() { |
| 307 | return cpu_stepping_; |
| 308 | } |
| 309 | |
| 310 | // Return the clockrate of the primary processor in Mhz. This value can be |
| 311 | // cached. Returns -1 on error. |
| 312 | int SystemInfo::GetMaxCpuSpeed() { |
| 313 | if (cpu_speed_) { |
| 314 | return cpu_speed_; |
| 315 | } |
| 316 | #if defined(WIN32) |
| 317 | HKEY key; |
| 318 | static const WCHAR keyName[] = |
| 319 | L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"; |
| 320 | |
| 321 | if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyName , 0, KEY_QUERY_VALUE, &key) |
| 322 | == ERROR_SUCCESS) { |
| 323 | DWORD data, len; |
| 324 | len = sizeof(data); |
| 325 | |
| 326 | if (RegQueryValueEx(key, L"~Mhz", 0, 0, reinterpret_cast<LPBYTE>(&data), |
| 327 | &len) == ERROR_SUCCESS) { |
| 328 | cpu_speed_ = data; |
| 329 | } else { |
| 330 | LOG(LS_WARNING) << "Failed to query registry value HKLM\\" << keyName |
| 331 | << "\\~Mhz"; |
| 332 | cpu_speed_ = -1; |
| 333 | } |
| 334 | |
| 335 | RegCloseKey(key); |
| 336 | } else { |
| 337 | LOG(LS_WARNING) << "Failed to open registry key HKLM\\" << keyName; |
| 338 | cpu_speed_ = -1; |
| 339 | } |
| 340 | #elif defined(IOS) || defined(OSX) |
| 341 | uint64_t sysctl_value; |
| 342 | size_t length = sizeof(sysctl_value); |
| 343 | int error = sysctlbyname("hw.cpufrequency_max", &sysctl_value, &length, |
| 344 | NULL, 0); |
| 345 | cpu_speed_ = !error ? static_cast<int>(sysctl_value/1000000) : -1; |
| 346 | #else |
| 347 | // TODO(fbarchard): Implement using proc/cpuinfo |
| 348 | cpu_speed_ = 0; |
| 349 | #endif |
| 350 | return cpu_speed_; |
| 351 | } |
| 352 | |
| 353 | // Dynamically check the current clockrate, which could be reduced because of |
| 354 | // powersaving profiles. Eventually for windows we want to query WMI for |
| 355 | // root\WMI::ProcessorPerformance.InstanceName="Processor_Number_0".frequency |
| 356 | int SystemInfo::GetCurCpuSpeed() { |
| 357 | #if defined(WIN32) |
| 358 | // TODO(fbarchard): Add WMI check, requires COM initialization |
| 359 | // NOTE(fbarchard): Testable on Sandy Bridge. |
| 360 | return GetMaxCpuSpeed(); |
| 361 | #elif defined(IOS) || defined(OSX) |
| 362 | uint64_t sysctl_value; |
| 363 | size_t length = sizeof(sysctl_value); |
| 364 | int error = sysctlbyname("hw.cpufrequency", &sysctl_value, &length, NULL, 0); |
| 365 | return !error ? static_cast<int>(sysctl_value/1000000) : GetMaxCpuSpeed(); |
| 366 | #else // LINUX || ANDROID |
| 367 | // TODO(fbarchard): Use proc/cpuinfo for Cur speed on Linux. |
| 368 | return GetMaxCpuSpeed(); |
| 369 | #endif |
| 370 | } |
| 371 | |
| 372 | // Returns the amount of installed physical memory in Bytes. Cacheable. |
| 373 | // Returns -1 on error. |
| 374 | int64 SystemInfo::GetMemorySize() { |
| 375 | if (memory_) { |
| 376 | return memory_; |
| 377 | } |
| 378 | |
| 379 | #if defined(WIN32) |
| 380 | MEMORYSTATUSEX status = {0}; |
| 381 | status.dwLength = sizeof(status); |
| 382 | |
| 383 | if (GlobalMemoryStatusEx(&status)) { |
| 384 | memory_ = status.ullTotalPhys; |
| 385 | } else { |
| 386 | LOG_GLE(LS_WARNING) << "GlobalMemoryStatusEx failed."; |
| 387 | memory_ = -1; |
| 388 | } |
| 389 | |
| 390 | #elif defined(OSX) || defined(IOS) |
| 391 | size_t len = sizeof(memory_); |
| 392 | int error = sysctlbyname("hw.memsize", &memory_, &len, NULL, 0); |
| 393 | if (error || memory_ == 0) { |
| 394 | memory_ = -1; |
| 395 | } |
| 396 | #else // LINUX || ANDROID |
| 397 | memory_ = static_cast<int64>(sysconf(_SC_PHYS_PAGES)) * |
| 398 | static_cast<int64>(sysconf(_SC_PAGESIZE)); |
| 399 | if (memory_ < 0) { |
| 400 | LOG(LS_WARNING) << "sysconf(_SC_PHYS_PAGES) failed." |
| 401 | << "sysconf(_SC_PHYS_PAGES) " << sysconf(_SC_PHYS_PAGES) |
| 402 | << "sysconf(_SC_PAGESIZE) " << sysconf(_SC_PAGESIZE); |
| 403 | memory_ = -1; |
| 404 | } |
| 405 | #endif |
| 406 | |
| 407 | return memory_; |
| 408 | } |
| 409 | |
| 410 | |
| 411 | // Return the name of the machine model we are currently running on. |
| 412 | // This is a human readable string that consists of the name and version |
| 413 | // number of the hardware, i.e 'MacBookAir1,1'. Returns an empty string if |
| 414 | // model can not be determined. The string is cached for subsequent calls. |
| 415 | std::string SystemInfo::GetMachineModel() { |
| 416 | if (!machine_model_.empty()) { |
| 417 | return machine_model_; |
| 418 | } |
| 419 | |
| 420 | #if defined(OSX) || defined(IOS) |
| 421 | char buffer[128]; |
| 422 | size_t length = sizeof(buffer); |
| 423 | int error = sysctlbyname("hw.model", buffer, &length, NULL, 0); |
| 424 | if (!error) { |
| 425 | machine_model_.assign(buffer, length - 1); |
| 426 | } else { |
| 427 | machine_model_.clear(); |
| 428 | } |
| 429 | #else |
| 430 | machine_model_ = "Not available"; |
| 431 | #endif |
| 432 | |
| 433 | return machine_model_; |
| 434 | } |
| 435 | |
| 436 | #ifdef OSX |
| 437 | // Helper functions to query IOKit for video hardware properties. |
| 438 | static CFTypeRef SearchForProperty(io_service_t port, CFStringRef name) { |
| 439 | return IORegistryEntrySearchCFProperty(port, kIOServicePlane, |
| 440 | name, kCFAllocatorDefault, |
| 441 | kIORegistryIterateRecursively | kIORegistryIterateParents); |
| 442 | } |
| 443 | |
| 444 | static void GetProperty(io_service_t port, CFStringRef name, int* value) { |
| 445 | if (!value) return; |
| 446 | CFTypeRef ref = SearchForProperty(port, name); |
| 447 | if (ref) { |
| 448 | CFTypeID refType = CFGetTypeID(ref); |
| 449 | if (CFNumberGetTypeID() == refType) { |
| 450 | CFNumberRef number = reinterpret_cast<CFNumberRef>(ref); |
| 451 | p_convertCFNumberToInt(number, value); |
| 452 | } else if (CFDataGetTypeID() == refType) { |
| 453 | CFDataRef data = reinterpret_cast<CFDataRef>(ref); |
| 454 | if (CFDataGetLength(data) == sizeof(UInt32)) { |
| 455 | *value = *reinterpret_cast<const UInt32*>(CFDataGetBytePtr(data)); |
| 456 | } |
| 457 | } |
| 458 | CFRelease(ref); |
| 459 | } |
| 460 | } |
| 461 | |
| 462 | static void GetProperty(io_service_t port, CFStringRef name, |
| 463 | std::string* value) { |
| 464 | if (!value) return; |
| 465 | CFTypeRef ref = SearchForProperty(port, name); |
| 466 | if (ref) { |
| 467 | CFTypeID refType = CFGetTypeID(ref); |
| 468 | if (CFStringGetTypeID() == refType) { |
| 469 | CFStringRef stringRef = reinterpret_cast<CFStringRef>(ref); |
| 470 | p_convertHostCFStringRefToCPPString(stringRef, *value); |
| 471 | } else if (CFDataGetTypeID() == refType) { |
| 472 | CFDataRef dataRef = reinterpret_cast<CFDataRef>(ref); |
| 473 | *value = std::string(reinterpret_cast<const char*>( |
| 474 | CFDataGetBytePtr(dataRef)), CFDataGetLength(dataRef)); |
| 475 | } |
| 476 | CFRelease(ref); |
| 477 | } |
| 478 | } |
| 479 | #endif |
| 480 | |
| 481 | // Fills a struct with information on the graphics adapater and returns true |
| 482 | // iff successful. |
| 483 | bool SystemInfo::GetGpuInfo(GpuInfo *info) { |
| 484 | if (!info) return false; |
| 485 | #if defined(WIN32) && !defined(EXCLUDE_D3D9) |
| 486 | D3DADAPTER_IDENTIFIER9 identifier; |
| 487 | HRESULT hr = E_FAIL; |
| 488 | HINSTANCE d3d_lib = LoadLibrary(L"d3d9.dll"); |
| 489 | |
| 490 | if (d3d_lib) { |
| 491 | typedef IDirect3D9* (WINAPI *D3DCreate9Proc)(UINT); |
| 492 | D3DCreate9Proc d3d_create_proc = reinterpret_cast<D3DCreate9Proc>( |
| 493 | GetProcAddress(d3d_lib, "Direct3DCreate9")); |
| 494 | if (d3d_create_proc) { |
| 495 | IDirect3D9* d3d = d3d_create_proc(D3D_SDK_VERSION); |
| 496 | if (d3d) { |
| 497 | hr = d3d->GetAdapterIdentifier(D3DADAPTER_DEFAULT, 0, &identifier); |
| 498 | d3d->Release(); |
| 499 | } |
| 500 | } |
| 501 | FreeLibrary(d3d_lib); |
| 502 | } |
| 503 | |
| 504 | if (hr != D3D_OK) { |
| 505 | LOG(LS_ERROR) << "Failed to access Direct3D9 information."; |
| 506 | return false; |
| 507 | } |
| 508 | |
| 509 | info->device_name = identifier.DeviceName; |
| 510 | info->description = identifier.Description; |
| 511 | info->vendor_id = identifier.VendorId; |
| 512 | info->device_id = identifier.DeviceId; |
| 513 | info->driver = identifier.Driver; |
| 514 | // driver_version format: product.version.subversion.build |
| 515 | std::stringstream ss; |
| 516 | ss << HIWORD(identifier.DriverVersion.HighPart) << "." |
| 517 | << LOWORD(identifier.DriverVersion.HighPart) << "." |
| 518 | << HIWORD(identifier.DriverVersion.LowPart) << "." |
| 519 | << LOWORD(identifier.DriverVersion.LowPart); |
| 520 | info->driver_version = ss.str(); |
| 521 | return true; |
| 522 | #elif defined(OSX) |
| 523 | // We'll query the IOKit for the gpu of the main display. |
| 524 | io_service_t display_service_port = CGDisplayIOServicePort( |
| 525 | kCGDirectMainDisplay); |
| 526 | GetProperty(display_service_port, CFSTR("vendor-id"), &info->vendor_id); |
| 527 | GetProperty(display_service_port, CFSTR("device-id"), &info->device_id); |
| 528 | GetProperty(display_service_port, CFSTR("model"), &info->description); |
| 529 | return true; |
| 530 | #else // LINUX || ANDROID |
| 531 | // TODO(fbarchard): Implement this on Linux |
| 532 | return false; |
| 533 | #endif |
| 534 | } |
| 535 | } // namespace talk_base |