1 files changed, 138 insertions, 31 deletions

diff --git a/CPP/Windows/System.cpp b/CPP/Windows/System.cpp
index 03c8988..4745785 100644
--- a/CPP/Windows/System.cpp
+++ b/CPP/Windows/System.cpp
@@ -25,6 +25,69 @@ namespace NSystem {
 
 #ifdef _WIN32
 
+/*
+note: returned value in 32-bit version can be limited by value 32.
+      while 64-bit version returns full value.
+GetMaximumProcessorCount(groupNumber) can return higher value than
+GetActiveProcessorCount(groupNumber) in some cases, because CPUs can be added.
+*/
+// typedef DWORD (WINAPI *Func_GetMaximumProcessorCount)(WORD GroupNumber);
+typedef DWORD (WINAPI *Func_GetActiveProcessorCount)(WORD GroupNumber);
+typedef WORD (WINAPI *Func_GetActiveProcessorGroupCount)(VOID);
+/*
+#if 0 && defined(ALL_PROCESSOR_GROUPS)
+#define MY_ALL_PROCESSOR_GROUPS   ALL_PROCESSOR_GROUPS
+#else
+#define MY_ALL_PROCESSOR_GROUPS   0xffff
+#endif
+*/
+
+Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
+
+bool CCpuGroups::Load()
+{
+  NumThreadsTotal = 0;
+  GroupSizes.Clear();
+  const HMODULE hmodule = ::GetModuleHandleA("kernel32.dll");
+  // Is_Win11_Groups = GetProcAddress(hmodule, "SetThreadSelectedCpuSetMasks") != NULL;
+  const
+      Func_GetActiveProcessorGroupCount
+        fn_GetActiveProcessorGroupCount = Z7_GET_PROC_ADDRESS(
+      Func_GetActiveProcessorGroupCount, hmodule,
+          "GetActiveProcessorGroupCount");
+  const
+      Func_GetActiveProcessorCount
+        fn_GetActiveProcessorCount = Z7_GET_PROC_ADDRESS(
+      Func_GetActiveProcessorCount, hmodule,
+          "GetActiveProcessorCount");
+  if (!fn_GetActiveProcessorGroupCount ||
+      !fn_GetActiveProcessorCount)
+    return false;
+
+  const unsigned numGroups = fn_GetActiveProcessorGroupCount();
+  if (numGroups == 0)
+    return false;
+  UInt32 sum = 0;
+  for (unsigned i = 0; i < numGroups; i++)
+  {
+    const UInt32 num = fn_GetActiveProcessorCount((WORD)i);
+    /*
+    if (num == 0)
+    {
+      // it means error
+      // but is it possible that some group is empty by some reason?
+      // GroupSizes.Clear();
+      // return false;
+    }
+    */
+    sum += num;
+    GroupSizes.Add(num);
+  }
+  NumThreadsTotal = sum;
+  // NumThreadsTotal = fn_GetActiveProcessorCount(MY_ALL_PROCESSOR_GROUPS);
+  return true;
+}
+
 UInt32 CountAffinity(DWORD_PTR mask)
 {
   UInt32 num = 0;
@@ -38,31 +101,62 @@ UInt32 CountAffinity(DWORD_PTR mask)
 
 BOOL CProcessAffinity::Get()
 {
-  #ifndef UNDER_CE
-  return GetProcessAffinityMask(GetCurrentProcess(), &processAffinityMask, &systemAffinityMask);
-  #else
-  return FALSE;
-  #endif
+  IsGroupMode = false;
+  Groups.Load();
+  // SetThreadAffinityMask(GetCurrentThread(), 1);
+  // SetProcessAffinityMask(GetCurrentProcess(), 1);
+  BOOL res = GetProcessAffinityMask(GetCurrentProcess(),
+      &processAffinityMask, &systemAffinityMask);
+  /* DOCs: On a system with more than 64 processors, if the threads
+     of the calling process  are in a single processor group, the
+     function sets the variables pointed to by lpProcessAffinityMask
+     and lpSystemAffinityMask to the process affinity mask and the
+     processor mask of active logical processors for that group.
+     If the calling process contains threads in multiple groups,
+     the function returns zero for both affinity masks
+
+     note: tested in Win10: GetProcessAffinityMask() doesn't return 0
+           in (processAffinityMask) and (systemAffinityMask) masks.
+     We need to test it in Win11: how to get mask==0 from GetProcessAffinityMask()?
+  */
+  if (!res)
+  {
+    processAffinityMask = 0;
+    systemAffinityMask = 0;
+  }
+  if (Groups.GroupSizes.Size() > 1 && Groups.NumThreadsTotal)
+    if (// !res ||
+        processAffinityMask == 0 || // to support case described in DOCs and for (!res) case
+        processAffinityMask == systemAffinityMask) // for default nonchanged affinity
+    {
+      // we set IsGroupMode only if processAffinity is default (not changed).
+      res = TRUE;
+      IsGroupMode = true;
+    }
+  return res;
 }
 
 
+UInt32 CProcessAffinity::Load_and_GetNumberOfThreads()
+{
+  if (Get())
+  {
+    const UInt32 numProcessors = GetNumProcessThreads();
+    if (numProcessors)
+      return numProcessors;
+  }
+  SYSTEM_INFO systemInfo;
+  GetSystemInfo(&systemInfo);
+  // the number of logical processors in the current group
+  return systemInfo.dwNumberOfProcessors;
+}
+
 UInt32 GetNumberOfProcessors()
 {
   // We need to know how many threads we can use.
   // By default the process is assigned to one group.
-  // So we get the number of logical processors (threads)
-  // assigned to current process in the current group.
-  // Group size can be smaller than total number logical processors, for exammple, 2x36
-
   CProcessAffinity pa;
-
-  if (pa.Get() && pa.processAffinityMask != 0)
-    return pa.GetNumProcessThreads();
-
-  SYSTEM_INFO systemInfo;
-  GetSystemInfo(&systemInfo);
-  // the number of logical processors in the current group
-  return (UInt32)systemInfo.dwNumberOfProcessors;
+  return pa.Load_and_GetNumberOfThreads();
 }
 
 #else
@@ -142,9 +236,9 @@ typedef BOOL (WINAPI *Func_GlobalMemoryStatusEx)(MY_LPMEMORYSTATUSEX lpBuffer);
 #endif // !UNDER_CE
 
   
-bool GetRamSize(UInt64 &size)
+bool GetRamSize(size_t &size)
 {
-  size = (UInt64)(sizeof(size_t)) << 29;
+  size = (size_t)sizeof(size_t) << 29;
 
   #ifndef UNDER_CE
     MY_MEMORYSTATUSEX stat;
@@ -167,11 +261,23 @@ bool GetRamSize(UInt64 &size)
           "GlobalMemoryStatusEx");
       if (fn && fn(&stat))
       {
-        size = MyMin(stat.ullTotalVirtual, stat.ullTotalPhys);
+        // (MY_MEMORYSTATUSEX::ullTotalVirtual) < 4 GiB in 32-bit mode
+        size_t size2 = (size_t)0 - 1;
+        if (size2 > stat.ullTotalPhys)
+            size2 = (size_t)stat.ullTotalPhys;
+        if (size2 > stat.ullTotalVirtual)
+            size2 = (size_t)stat.ullTotalVirtual;
+        size = size2;
         return true;
       }
     #endif
   
+    // On computers with more than 4 GB of memory:
+    //   new docs  : GlobalMemoryStatus can report (-1) value to indicate an overflow.
+    //   some old docs : GlobalMemoryStatus can report (modulo 4 GiB) value.
+    //                   (for example, if 5 GB total memory, it could report 1 GB).
+    // We don't want to get (modulo 4 GiB) value.
+    // So we use GlobalMemoryStatusEx() instead.
     {
       MEMORYSTATUS stat2;
       stat2.dwLength = sizeof(stat2);
@@ -187,9 +293,11 @@ bool GetRamSize(UInt64 &size)
 // POSIX
 // #include <stdio.h>
 
-bool GetRamSize(UInt64 &size)
+bool GetRamSize(size_t &size)
 {
-  size = (UInt64)(sizeof(size_t)) << 29;
+  UInt64 size64;
+  size = (size_t)sizeof(size_t) << 29;
+  size64 = size;
 
 #if defined(__APPLE__) || defined(__DragonFly__) || \
     defined(BSD) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
@@ -215,7 +323,7 @@ bool GetRamSize(UInt64 &size)
     // we use strict check (size_sys == sizeof(val)) for returned value
     // because big-endian encoding is possible:
     if (res == 0 && size_sys == sizeof(val) && val)
-      size = val;
+      size64 = val;
     else
     {
       uint32_t val32 = 0;
@@ -223,12 +331,12 @@ bool GetRamSize(UInt64 &size)
       res = sysctl(mib, 2, &val32, &size_sys, NULL, 0);
       // printf("\n sysctl res=%d val=%llx size_sys = %d, %d\n", res, (long long int)val32, (int)size_sys, errno);
       if (res == 0 && size_sys == sizeof(val32) && val32)
-        size = val32;
+        size64 = val32;
     }
 
   #elif defined(_AIX)
     #if defined(_SC_AIX_REALMEM) // AIX
-      size = (UInt64)sysconf(_SC_AIX_REALMEM) * 1024;
+      size64 = (UInt64)sysconf(_SC_AIX_REALMEM) * 1024;
     #endif
   #elif 0 || defined(__sun)
     #if defined(_SC_PHYS_PAGES) && defined(_SC_PAGESIZE)
@@ -240,7 +348,7 @@ bool GetRamSize(UInt64 &size)
       // printf("\n_SC_PHYS_PAGES (hex) = %lx", (unsigned long)phys_pages);
       // printf("\n_SC_PAGESIZE = %lu\n", (unsigned long)page_size);
       if (phys_pages != -1 && page_size != -1)
-        size = (UInt64)(Int64)phys_pages * (UInt64)(Int64)page_size;
+        size64 = (UInt64)(Int64)phys_pages * (UInt64)(Int64)page_size;
     }
     #endif
   #elif defined(__gnu_hurd__)
@@ -253,7 +361,7 @@ bool GetRamSize(UInt64 &size)
   struct sysinfo info;
   if (::sysinfo(&info) != 0)
     return false;
-  size = (UInt64)info.mem_unit * info.totalram;
+  size64 = (UInt64)info.mem_unit * info.totalram;
   /*
   printf("\n mem_unit  = %lld", (UInt64)info.mem_unit);
   printf("\n totalram  = %lld", (UInt64)info.totalram);
@@ -262,10 +370,9 @@ bool GetRamSize(UInt64 &size)
 
   #endif
 
-  const UInt64 kLimit = (UInt64)1 << (sizeof(size_t) * 8 - 1);
-  if (size > kLimit)
-    size = kLimit;
-
+  size = (size_t)1 << (sizeof(size_t) * 8 - 1);
+  if (size > size64)
+      size = (size_t)size64;
   return true;
 }