1 // Windows/System.cpp
2
3 #include "StdAfx.h"
4
5 #ifndef _WIN32
6 #include <unistd.h>
7 #include <limits.h>
8 #if defined(__APPLE__) || defined(__DragonFly__) || \
9 defined(BSD) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
10 #include <sys/sysctl.h>
11 #else
12 #include <sys/sysinfo.h>
13 #endif
14 #endif
15
16 #include "../Common/Defs.h"
17 // #include "../Common/MyWindows.h"
18
19 // #include "../../C/CpuArch.h"
20
21 #include "System.h"
22
23 namespace NWindows {
24 namespace NSystem {
25
26 #ifdef _WIN32
27
CountAffinity(DWORD_PTR mask)28 UInt32 CountAffinity(DWORD_PTR mask)
29 {
30 UInt32 num = 0;
31 for (unsigned i = 0; i < sizeof(mask) * 8; i++)
32 {
33 num += (UInt32)(mask & 1);
34 mask >>= 1;
35 }
36 return num;
37 }
38
Get()39 BOOL CProcessAffinity::Get()
40 {
41 #ifndef UNDER_CE
42 return GetProcessAffinityMask(GetCurrentProcess(), &processAffinityMask, &systemAffinityMask);
43 #else
44 return FALSE;
45 #endif
46 }
47
48
GetNumberOfProcessors()49 UInt32 GetNumberOfProcessors()
50 {
51 // We need to know how many threads we can use.
52 // By default the process is assigned to one group.
53 // So we get the number of logical processors (threads)
54 // assigned to current process in the current group.
55 // Group size can be smaller than total number logical processors, for exammple, 2x36
56
57 CProcessAffinity pa;
58
59 if (pa.Get() && pa.processAffinityMask != 0)
60 return pa.GetNumProcessThreads();
61
62 SYSTEM_INFO systemInfo;
63 GetSystemInfo(&systemInfo);
64 // the number of logical processors in the current group
65 return (UInt32)systemInfo.dwNumberOfProcessors;
66 }
67
68 #else
69
70
71 BOOL CProcessAffinity::Get()
72 {
73 numSysThreads = GetNumberOfProcessors();
74
75 /*
76 numSysThreads = 8;
77 for (unsigned i = 0; i < numSysThreads; i++)
78 CpuSet_Set(&cpu_set, i);
79 return TRUE;
80 */
81
82 #ifdef Z7_AFFINITY_SUPPORTED
83
84 // numSysThreads = sysconf(_SC_NPROCESSORS_ONLN); // The number of processors currently online
85 if (sched_getaffinity(0, sizeof(cpu_set), &cpu_set) != 0)
86 return FALSE;
87 return TRUE;
88
89 #else
90
91 // cpu_set = ((CCpuSet)1 << (numSysThreads)) - 1;
92 return TRUE;
93 // errno = ENOSYS;
94 // return FALSE;
95
96 #endif
97 }
98
99 UInt32 GetNumberOfProcessors()
100 {
101 #ifndef Z7_ST
102 long n = sysconf(_SC_NPROCESSORS_CONF); // The number of processors configured
103 if (n < 1)
104 n = 1;
105 return (UInt32)n;
106 #else
107 return 1;
108 #endif
109 }
110
111 #endif
112
113
114 #ifdef _WIN32
115
116 #ifndef UNDER_CE
117
118 #if !defined(_WIN64) && \
119 (defined(__MINGW32_VERSION) || defined(Z7_OLD_WIN_SDK))
120
121 typedef struct {
122 DWORD dwLength;
123 DWORD dwMemoryLoad;
124 DWORDLONG ullTotalPhys;
125 DWORDLONG ullAvailPhys;
126 DWORDLONG ullTotalPageFile;
127 DWORDLONG ullAvailPageFile;
128 DWORDLONG ullTotalVirtual;
129 DWORDLONG ullAvailVirtual;
130 DWORDLONG ullAvailExtendedVirtual;
131 } MY_MEMORYSTATUSEX, *MY_LPMEMORYSTATUSEX;
132
133 #else
134
135 #define MY_MEMORYSTATUSEX MEMORYSTATUSEX
136 #define MY_LPMEMORYSTATUSEX LPMEMORYSTATUSEX
137
138 #endif
139
140 typedef BOOL (WINAPI *Func_GlobalMemoryStatusEx)(MY_LPMEMORYSTATUSEX lpBuffer);
141
142 #endif // !UNDER_CE
143
144
GetRamSize(size_t & size)145 bool GetRamSize(size_t &size)
146 {
147 size = (size_t)sizeof(size_t) << 29;
148
149 #ifndef UNDER_CE
150 MY_MEMORYSTATUSEX stat;
151 stat.dwLength = sizeof(stat);
152 #endif
153
154 #ifdef _WIN64
155
156 if (!::GlobalMemoryStatusEx(&stat))
157 return false;
158 size = MyMin(stat.ullTotalVirtual, stat.ullTotalPhys);
159 return true;
160
161 #else
162
163 #ifndef UNDER_CE
164 const
165 Func_GlobalMemoryStatusEx fn = Z7_GET_PROC_ADDRESS(
166 Func_GlobalMemoryStatusEx, ::GetModuleHandleA("kernel32.dll"),
167 "GlobalMemoryStatusEx");
168 if (fn && fn(&stat))
169 {
170 // (MY_MEMORYSTATUSEX::ullTotalVirtual) < 4 GiB in 32-bit mode
171 size_t size2 = (size_t)0 - 1;
172 if (size2 > stat.ullTotalPhys)
173 size2 = (size_t)stat.ullTotalPhys;
174 if (size2 > stat.ullTotalVirtual)
175 size2 = (size_t)stat.ullTotalVirtual;
176 size = size2;
177 return true;
178 }
179 #endif
180
181 // On computers with more than 4 GB of memory:
182 // new docs : GlobalMemoryStatus can report (-1) value to indicate an overflow.
183 // some old docs : GlobalMemoryStatus can report (modulo 4 GiB) value.
184 // (for example, if 5 GB total memory, it could report 1 GB).
185 // We don't want to get (modulo 4 GiB) value.
186 // So we use GlobalMemoryStatusEx() instead.
187 {
188 MEMORYSTATUS stat2;
189 stat2.dwLength = sizeof(stat2);
190 ::GlobalMemoryStatus(&stat2);
191 size = MyMin(stat2.dwTotalVirtual, stat2.dwTotalPhys);
192 return true;
193 }
194 #endif
195 }
196
197 #else
198
199 // POSIX
200 // #include <stdio.h>
201
GetRamSize(size_t & size)202 bool GetRamSize(size_t &size)
203 {
204 UInt64 size64;
205 size = (size_t)sizeof(size_t) << 29;
206 size64 = size;
207
208 #if defined(__APPLE__) || defined(__DragonFly__) || \
209 defined(BSD) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
210
211 uint64_t val = 0;
212 int mib[2];
213 mib[0] = CTL_HW;
214
215 #ifdef HW_MEMSIZE
216 mib[1] = HW_MEMSIZE;
217 // printf("\n sysctl HW_MEMSIZE");
218 #elif defined(HW_PHYSMEM64)
219 mib[1] = HW_PHYSMEM64;
220 // printf("\n sysctl HW_PHYSMEM64");
221 #else
222 mib[1] = HW_PHYSMEM;
223 // printf("\n sysctl HW_PHYSMEM");
224 #endif
225
226 size_t size_sys = sizeof(val);
227 int res = sysctl(mib, 2, &val, &size_sys, NULL, 0);
228 // printf("\n sysctl res=%d val=%llx size_sys = %d, %d\n", res, (long long int)val, (int)size_sys, errno);
229 // we use strict check (size_sys == sizeof(val)) for returned value
230 // because big-endian encoding is possible:
231 if (res == 0 && size_sys == sizeof(val) && val)
232 size64 = val;
233 else
234 {
235 uint32_t val32 = 0;
236 size_sys = sizeof(val32);
237 res = sysctl(mib, 2, &val32, &size_sys, NULL, 0);
238 // printf("\n sysctl res=%d val=%llx size_sys = %d, %d\n", res, (long long int)val32, (int)size_sys, errno);
239 if (res == 0 && size_sys == sizeof(val32) && val32)
240 size64 = val32;
241 }
242
243 #elif defined(_AIX)
244 #if defined(_SC_AIX_REALMEM) // AIX
245 size64 = (UInt64)sysconf(_SC_AIX_REALMEM) * 1024;
246 #endif
247 #elif 0 || defined(__sun)
248 #if defined(_SC_PHYS_PAGES) && defined(_SC_PAGESIZE)
249 // FreeBSD, Linux, OpenBSD, and Solaris.
250 {
251 const long phys_pages = sysconf(_SC_PHYS_PAGES);
252 const long page_size = sysconf(_SC_PAGESIZE);
253 // #pragma message("GetRamSize : sysconf(_SC_PHYS_PAGES) * sysconf(_SC_PAGESIZE)")
254 // printf("\n_SC_PHYS_PAGES (hex) = %lx", (unsigned long)phys_pages);
255 // printf("\n_SC_PAGESIZE = %lu\n", (unsigned long)page_size);
256 if (phys_pages != -1 && page_size != -1)
257 size64 = (UInt64)(Int64)phys_pages * (UInt64)(Int64)page_size;
258 }
259 #endif
260 #elif defined(__gnu_hurd__)
261 // fixme
262 #elif defined(__FreeBSD_kernel__) && defined(__GLIBC__)
263 // GNU/kFreeBSD Debian
264 // fixme
265 #else
266
267 struct sysinfo info;
268 if (::sysinfo(&info) != 0)
269 return false;
270 size64 = (UInt64)info.mem_unit * info.totalram;
271 /*
272 printf("\n mem_unit = %lld", (UInt64)info.mem_unit);
273 printf("\n totalram = %lld", (UInt64)info.totalram);
274 printf("\n freeram = %lld", (UInt64)info.freeram);
275 */
276
277 #endif
278
279 size = (size_t)1 << (sizeof(size_t) * 8 - 1);
280 if (size > size64)
281 size = (size_t)size64;
282 return true;
283 }
284
285 #endif
286
287
Get_File_OPEN_MAX()288 unsigned long Get_File_OPEN_MAX()
289 {
290 #ifdef _WIN32
291 return (1 << 24) - (1 << 16); // ~16M handles
292 #else
293 // some linux versions have default open file limit for user process of 1024 files.
294 long n = sysconf(_SC_OPEN_MAX);
295 // n = -1; // for debug
296 // n = 9; // for debug
297 if (n < 1)
298 {
299 // n = OPEN_MAX; // ???
300 // n = FOPEN_MAX; // = 16 : <stdio.h>
301 #ifdef _POSIX_OPEN_MAX
302 n = _POSIX_OPEN_MAX; // = 20 : <limits.h>
303 #else
304 n = 30; // our limit
305 #endif
306 }
307 return (unsigned long)n;
308 #endif
309 }
310
Get_File_OPEN_MAX_Reduced_for_3_tasks()311 unsigned Get_File_OPEN_MAX_Reduced_for_3_tasks()
312 {
313 unsigned long numFiles_OPEN_MAX = NSystem::Get_File_OPEN_MAX();
314 const unsigned delta = 10; // the reserve for another internal needs of process
315 if (numFiles_OPEN_MAX > delta)
316 numFiles_OPEN_MAX -= delta;
317 else
318 numFiles_OPEN_MAX = 1;
319 numFiles_OPEN_MAX /= 3; // we suppose that we have up to 3 tasks in total for multiple file processing
320 numFiles_OPEN_MAX = MyMax(numFiles_OPEN_MAX, (unsigned long)3);
321 unsigned n = (unsigned)(int)-1;
322 if (n > numFiles_OPEN_MAX)
323 n = (unsigned)numFiles_OPEN_MAX;
324 return n;
325 }
326
327 }}
328