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(UInt64 & size)145 bool GetRamSize(UInt64 &size)
146 {
147 size = (UInt64)(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 size = MyMin(stat.ullTotalVirtual, stat.ullTotalPhys);
171 return true;
172 }
173 #endif
174
175 {
176 MEMORYSTATUS stat2;
177 stat2.dwLength = sizeof(stat2);
178 ::GlobalMemoryStatus(&stat2);
179 size = MyMin(stat2.dwTotalVirtual, stat2.dwTotalPhys);
180 return true;
181 }
182 #endif
183 }
184
185 #else
186
187 // POSIX
188 // #include <stdio.h>
189
GetRamSize(UInt64 & size)190 bool GetRamSize(UInt64 &size)
191 {
192 size = (UInt64)(sizeof(size_t)) << 29;
193
194 #if defined(__APPLE__) || defined(__DragonFly__) || \
195 defined(BSD) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
196
197 uint64_t val = 0;
198 int mib[2];
199 mib[0] = CTL_HW;
200
201 #ifdef HW_MEMSIZE
202 mib[1] = HW_MEMSIZE;
203 // printf("\n sysctl HW_MEMSIZE");
204 #elif defined(HW_PHYSMEM64)
205 mib[1] = HW_PHYSMEM64;
206 // printf("\n sysctl HW_PHYSMEM64");
207 #else
208 mib[1] = HW_PHYSMEM;
209 // printf("\n sysctl HW_PHYSMEM");
210 #endif
211
212 size_t size_sys = sizeof(val);
213 int res = sysctl(mib, 2, &val, &size_sys, NULL, 0);
214 // printf("\n sysctl res=%d val=%llx size_sys = %d, %d\n", res, (long long int)val, (int)size_sys, errno);
215 // we use strict check (size_sys == sizeof(val)) for returned value
216 // because big-endian encoding is possible:
217 if (res == 0 && size_sys == sizeof(val) && val)
218 size = val;
219 else
220 {
221 uint32_t val32 = 0;
222 size_sys = sizeof(val32);
223 res = sysctl(mib, 2, &val32, &size_sys, NULL, 0);
224 // printf("\n sysctl res=%d val=%llx size_sys = %d, %d\n", res, (long long int)val32, (int)size_sys, errno);
225 if (res == 0 && size_sys == sizeof(val32) && val32)
226 size = val32;
227 }
228
229 #elif defined(_AIX)
230 #if defined(_SC_AIX_REALMEM) // AIX
231 size = (UInt64)sysconf(_SC_AIX_REALMEM) * 1024;
232 #endif
233 #elif 0 || defined(__sun)
234 #if defined(_SC_PHYS_PAGES) && defined(_SC_PAGESIZE)
235 // FreeBSD, Linux, OpenBSD, and Solaris.
236 {
237 const long phys_pages = sysconf(_SC_PHYS_PAGES);
238 const long page_size = sysconf(_SC_PAGESIZE);
239 // #pragma message("GetRamSize : sysconf(_SC_PHYS_PAGES) * sysconf(_SC_PAGESIZE)")
240 // printf("\n_SC_PHYS_PAGES (hex) = %lx", (unsigned long)phys_pages);
241 // printf("\n_SC_PAGESIZE = %lu\n", (unsigned long)page_size);
242 if (phys_pages != -1 && page_size != -1)
243 size = (UInt64)(Int64)phys_pages * (UInt64)(Int64)page_size;
244 }
245 #endif
246 #elif defined(__gnu_hurd__)
247 // fixme
248 #elif defined(__FreeBSD_kernel__) && defined(__GLIBC__)
249 // GNU/kFreeBSD Debian
250 // fixme
251 #else
252
253 struct sysinfo info;
254 if (::sysinfo(&info) != 0)
255 return false;
256 size = (UInt64)info.mem_unit * info.totalram;
257 /*
258 printf("\n mem_unit = %lld", (UInt64)info.mem_unit);
259 printf("\n totalram = %lld", (UInt64)info.totalram);
260 printf("\n freeram = %lld", (UInt64)info.freeram);
261 */
262
263 #endif
264
265 const UInt64 kLimit = (UInt64)1 << (sizeof(size_t) * 8 - 1);
266 if (size > kLimit)
267 size = kLimit;
268
269 return true;
270 }
271
272 #endif
273
274
Get_File_OPEN_MAX()275 unsigned long Get_File_OPEN_MAX()
276 {
277 #ifdef _WIN32
278 return (1 << 24) - (1 << 16); // ~16M handles
279 #else
280 // some linux versions have default open file limit for user process of 1024 files.
281 long n = sysconf(_SC_OPEN_MAX);
282 // n = -1; // for debug
283 // n = 9; // for debug
284 if (n < 1)
285 {
286 // n = OPEN_MAX; // ???
287 // n = FOPEN_MAX; // = 16 : <stdio.h>
288 #ifdef _POSIX_OPEN_MAX
289 n = _POSIX_OPEN_MAX; // = 20 : <limits.h>
290 #else
291 n = 30; // our limit
292 #endif
293 }
294 return (unsigned long)n;
295 #endif
296 }
297
Get_File_OPEN_MAX_Reduced_for_3_tasks()298 unsigned Get_File_OPEN_MAX_Reduced_for_3_tasks()
299 {
300 unsigned long numFiles_OPEN_MAX = NSystem::Get_File_OPEN_MAX();
301 const unsigned delta = 10; // the reserve for another internal needs of process
302 if (numFiles_OPEN_MAX > delta)
303 numFiles_OPEN_MAX -= delta;
304 else
305 numFiles_OPEN_MAX = 1;
306 numFiles_OPEN_MAX /= 3; // we suppose that we have up to 3 tasks in total for multiple file processing
307 numFiles_OPEN_MAX = MyMax(numFiles_OPEN_MAX, (unsigned long)3);
308 unsigned n = (unsigned)(int)-1;
309 if (n > numFiles_OPEN_MAX)
310 n = (unsigned)numFiles_OPEN_MAX;
311 return n;
312 }
313
314 }}
315