1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
/*
* Copyright 2008 The WebRTC Project Authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/base/systeminfo.h"
#if defined(WEBRTC_WIN)
#include <winsock2.h>
#include <windows.h>
#ifndef EXCLUDE_D3D9
#include <d3d9.h>
#endif
#include <intrin.h> // for __cpuid()
#elif defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
#include <ApplicationServices/ApplicationServices.h>
#include <CoreServices/CoreServices.h>
#elif defined(WEBRTC_LINUX)
#include <unistd.h>
#endif
#if defined(WEBRTC_MAC)
#include <sys/sysctl.h>
#endif
#include "webrtc/base/common.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/stringutils.h"
namespace rtc {
// See Also: http://msdn.microsoft.com/en-us/library/ms683194(v=vs.85).aspx
#if !defined(WEBRTC_WIN)
// TODO(fbarchard): Use gcc 4.4 provided cpuid intrinsic
// 32 bit fpic requires ebx be preserved
#if (defined(__pic__) || defined(__APPLE__)) && defined(__i386__)
static inline void __cpuid(int cpu_info[4], int info_type) {
__asm__ volatile ( // NOLINT
"mov %%ebx, %%edi\n"
"cpuid\n"
"xchg %%edi, %%ebx\n"
: "=a"(cpu_info[0]), "=D"(cpu_info[1]), "=c"(cpu_info[2]), "=d"(cpu_info[3])
: "a"(info_type)
); // NOLINT
}
#elif defined(__i386__) || defined(__x86_64__)
static inline void __cpuid(int cpu_info[4], int info_type) {
__asm__ volatile ( // NOLINT
"cpuid\n"
: "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]), "=d"(cpu_info[3])
: "a"(info_type)
); // NOLINT
}
#endif
#endif // WEBRTC_WIN
static int DetectNumberOfCores() {
// We fall back on assuming a single core in case of errors.
int number_of_cores = 1;
#if defined(WEBRTC_WIN)
SYSTEM_INFO si;
GetSystemInfo(&si);
number_of_cores = static_cast<int>(si.dwNumberOfProcessors);
#elif defined(WEBRTC_LINUX) || defined(WEBRTC_ANDROID)
number_of_cores = static_cast<int>(sysconf(_SC_NPROCESSORS_ONLN));
#elif defined(WEBRTC_MAC)
int name[] = {CTL_HW, HW_AVAILCPU};
size_t size = sizeof(number_of_cores);
if (0 != sysctl(name, 2, &number_of_cores, &size, NULL, 0)) {
LOG(LS_ERROR) << "Failed to get number of cores";
number_of_cores = 1;
}
#else
LOG(LS_ERROR) << "No function to get number of cores";
#endif
LOG(LS_INFO) << "Available number of cores: " << number_of_cores;
return number_of_cores;
}
// Statically cache the number of system cores available since if the process
// is running in a sandbox, we may only be able to read the value once (before
// the sandbox is initialized) and not thereafter.
// For more information see crbug.com/176522.
int SystemInfo::logical_cpus_ = 0;
SystemInfo::SystemInfo() {
}
// Return the number of cpu threads available to the system.
// static
int SystemInfo::GetMaxCpus() {
if (!logical_cpus_)
logical_cpus_ = DetectNumberOfCores();
return logical_cpus_;
}
// Return the number of cpus available to the process. Since affinity can be
// changed on the fly, do not cache this value.
// Can be affected by heat.
int SystemInfo::GetCurCpus() {
int cur_cpus = 0;
#if defined(WEBRTC_WIN)
DWORD_PTR process_mask = 0;
DWORD_PTR system_mask = 0;
::GetProcessAffinityMask(::GetCurrentProcess(), &process_mask, &system_mask);
for (int i = 0; i < sizeof(DWORD_PTR) * 8; ++i) {
if (process_mask & 1)
++cur_cpus;
process_mask >>= 1;
}
#elif defined(WEBRTC_MAC)
uint32_t sysctl_value;
size_t length = sizeof(sysctl_value);
int error = sysctlbyname("hw.ncpu", &sysctl_value, &length, NULL, 0);
cur_cpus = !error ? static_cast<int>(sysctl_value) : 1;
#else
// Linux, Solaris, WEBRTC_ANDROID
cur_cpus = GetMaxCpus();
#endif
return cur_cpus;
}
// Return the type of this CPU.
SystemInfo::Architecture SystemInfo::GetCpuArchitecture() {
#if defined(__arm__) || defined(_M_ARM)
return SI_ARCH_ARM;
#elif defined(__x86_64__) || defined(_M_X64)
return SI_ARCH_X64;
#elif defined(__i386__) || defined(_M_IX86)
return SI_ARCH_X86;
#else
return SI_ARCH_UNKNOWN;
#endif
}
// Returns the vendor string from the cpu, e.g. "GenuineIntel", "AuthenticAMD".
// See "Intel Processor Identification and the CPUID Instruction"
// (Intel document number: 241618)
std::string SystemInfo::GetCpuVendor() {
#if defined(CPU_X86)
int cpu_info[4];
__cpuid(cpu_info, 0);
cpu_info[0] = cpu_info[1]; // Reorder output
cpu_info[1] = cpu_info[3];
// cpu_info[2] = cpu_info[2]; // Avoid -Werror=self-assign
cpu_info[3] = 0;
return std::string(reinterpret_cast<char*>(&cpu_info[0]));
#elif defined(CPU_ARM)
return "ARM";
#else
return "Undefined";
#endif
}
// Returns the amount of installed physical memory in Bytes. Cacheable.
// Returns -1 on error.
int64_t SystemInfo::GetMemorySize() {
int64_t memory = -1;
#if defined(WEBRTC_WIN)
MEMORYSTATUSEX status = {0};
status.dwLength = sizeof(status);
if (GlobalMemoryStatusEx(&status)) {
memory = status.ullTotalPhys;
} else {
LOG_GLE(LS_WARNING) << "GlobalMemoryStatusEx failed.";
}
#elif defined(WEBRTC_MAC)
size_t len = sizeof(memory);
int error = sysctlbyname("hw.memsize", &memory, &len, NULL, 0);
if (error || memory == 0)
memory = -1;
#elif defined(WEBRTC_LINUX)
memory = static_cast<int64_t>(sysconf(_SC_PHYS_PAGES)) *
static_cast<int64_t>(sysconf(_SC_PAGESIZE));
if (memory < 0) {
LOG(LS_WARNING) << "sysconf(_SC_PHYS_PAGES) failed."
<< "sysconf(_SC_PHYS_PAGES) " << sysconf(_SC_PHYS_PAGES)
<< "sysconf(_SC_PAGESIZE) " << sysconf(_SC_PAGESIZE);
memory = -1;
}
#endif
return memory;
}
// Return the name of the machine model we are currently running on.
// This is a human readable string that consists of the name and version
// number of the hardware, i.e 'MacBookAir1,1'. Returns an empty string if
// model can not be determined.
std::string SystemInfo::GetMachineModel() {
#if defined(WEBRTC_MAC)
char buffer[128];
size_t length = sizeof(buffer);
int error = sysctlbyname("hw.model", buffer, &length, NULL, 0);
if (!error)
return std::string(buffer, length - 1);
return std::string();
#else
return "Not available";
#endif
}
} // namespace rtc
|
