Update permpure_full.cpp

Author: Yusheng-Hu

permpure_full.cpp

@@ -5,19 +5,25 @@
  * @license This project is licensed under the MIT License - see the LICENSE file for details.
  * * Program Details:
  * - Implements an efficient iterative permutation generation logic.
- * - Features: Windows CPU Affinity binding, High-precision timing (QPC), 
+ * - Features: Cross-platform CPU Affinity binding, High-precision timing (std::chrono), 
  * and optimization-resistant checksums.
  * - Performance: Designed for minimal branch misprediction and low overhead.
  * * Environment:
- * - Platform: Windows (Requires <windows.h>)
+ * - Platform: Windows / Linux (Auto-switching headers)
  * - Compiler: GCC/MinGW (supports __builtin_LINE) or MSVC
- * * Usage:
- * Adjust the 'PERM_SIZE' macro to change the permutation set size. 
- * Note: PERM_SIZE > 14 may require significant time.
  */
-#include "stdio.h"
-#include "time.h"
-#include "windows.h" // Add Windows API header file
+
+#include <stdio.h>
+#include <time.h>
+#include <chrono>
+
+#ifdef _WIN32
+    #include <windows.h>
+#else
+    #include <sched.h>
+    #include <pthread.h>
+#endif
+
 #ifndef PERM_SIZE
 #define PERM_SIZE 12
 #endif
@@ -26,101 +32,89 @@
 // #define DEBUG
 
 #ifdef DEBUG
-#define COUNT_PROCESS() ProcessCount[__builtin_LINE()]++
+#define COUNT_PURECESS() ProcessCount[__builtin_LINE()]++
 #else
-#define COUNT_PROCESS() // Empty definition, no operation in non-DEBUG mode
+#define COUNT_PURECESS() 
 #endif
 
 int main() {
-  
-  // Bind to CPU core (core 3)
-  DWORD_PTR mask = 8; // CPU mask for core 3 (1 << 3 = 8)
-  HANDLE thread = GetCurrentThread();
-  SetThreadAffinityMask(thread, mask);
-  // Add checksum to prevent over-optimization
-  unsigned long long checksum = 0;
-
-  unsigned long long purecessCount[200] = {0};
-  int volatile i = 0;
-  int j = 0;
-  int C[PERM_SIZE] = {0}, D[PERM_SIZE] = {0}, M[PERM_SIZE] = {0};
-
-  // High precision timer variables
-  LARGE_INTEGER start, finish, frequency;
-  double duration;
-
-  // Get high precision timer frequency
-  QueryPerformanceFrequency(&frequency);
-  // Record start time
-  QueryPerformanceCounter(&start);
-
-  while (C[0] < 1) {
-    COUNT_pureCESS();
-    for (; i < PERM_SIZE-1; ++i) {
-      COUNT_pureCESS();
-      D[i] = D[C[i]];
-      D[C[i]] = i;
-    }
+    // --- Set CPU Affinity for Accurate Benchmarking ---
+#ifdef _WIN32
+    DWORD_PTR mask = 8; // CPU mask for core 3
+    SetThreadAffinityMask(GetCurrentThread(), mask);
+#else
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    CPU_SET(1, &cpuset); // Bind to Core 1 on Linux
+    sched_setaffinity(0, sizeof(cpu_set_t), &cpuset);
+#endif
 
-    for (int ii = 0; ii < PERM_SIZE; ii++)
-    {
-      COUNT_pureCESS();
-      D[PERM_SIZE-1] = D[ii];
-      D[ii] = PERM_SIZE-1;
-      checksum += D[PERM_SIZE-1];
+    unsigned long long checksum = 0;
+    unsigned long long ProcessCount[200] = {0};
+    int volatile i = 0;
+    int j = 0;
+    int C[PERM_SIZE] = {0}, D[PERM_SIZE] = {0}, M[PERM_SIZE] = {0};
+
+    // --- High Precision Timing ---
+    auto start = std::chrono::high_resolution_clock::now();
+
+    // Main Algorithm Loop
+    while (C[0] < 1) {
+        COUNT_PURECESS();
+        for (; i < PERM_SIZE-1; ++i) {
+            COUNT_PURECESS();
+            D[i] = D[C[i]];
+            D[C[i]] = i;
+        }
+
+        for (int ii = 0; ii < PERM_SIZE; ii++) {
+            COUNT_PURECESS();
+            D[PERM_SIZE-1] = D[ii];
+            D[ii] = PERM_SIZE-1;
+            checksum += D[PERM_SIZE-1];
 
 #if PERM_SIZE <= LittleNumber
-      // Print D array
-      printf("\n");
-      for (int jj = 0; jj < PERM_SIZE; jj++) {
-        printf("%d,", D[jj]);
-      }
+            printf("\n");
+            for (int jj = 0; jj < PERM_SIZE; jj++) {
+                printf("%d,", D[jj]);
+            }
 #endif
-      D[ii] = D[PERM_SIZE-1];
-    }
-
-    D[C[PERM_SIZE - 2]] = D[PERM_SIZE - 2];
-
-    C[PERM_SIZE - 2]++;
-    for (i = PERM_SIZE - 2; (i > 0) && (C[i] > i); i--) {
-      COUNT_pureCESS();
-      C[i] = 0;
-      C[i - 1]++;
-      D[C[i - 1] - 1] = D[i - 1];
+            D[ii] = D[PERM_SIZE-1];
+        }
+
+        D[C[PERM_SIZE - 2]] = D[PERM_SIZE - 2];
+
+        C[PERM_SIZE - 2]++;
+        for (i = PERM_SIZE - 2; (i > 0) && (C[i] > i); i--) {
+            COUNT_PURECESS();
+            C[i] = 0;
+            C[i - 1]++;
+            D[C[i - 1] - 1] = D[i - 1];
+        }
     }
-  }
 
-  // Record end time
-  QueryPerformanceCounter(&finish);
-  // Calculate duration (seconds) = (end count - start count) / frequency
-  duration = (double)(finish.QuadPart - start.QuadPart) / frequency.QuadPart;
-  printf("\npermpure_full\t%u\t%lf", PERM_SIZE, duration);
+    auto finish = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> duration = finish - start;
 
-  // Prevent the compiler from optimizing too much
-  printf("\nD[PERM_SIZE-1] = %d, checksum = %llu", D[PERM_SIZE-1], checksum);
+    printf("\npermpure_full\t%u\t%lf seconds", PERM_SIZE, duration.count());
+    printf("\nD[PERM_SIZE-1] = %d, checksum = %llu\n", D[PERM_SIZE-1], checksum);
 
 #ifdef DEBUG
-  unsigned long long perm = 1;
-  unsigned long long PermValue[PERM_SIZE] = {0};
-  unsigned long long SumPermValue[PERM_SIZE] = {0};
-  PermValue[0] = 1;
-  SumPermValue[0] = 0;
-  for (i = 1; i <= PERM_SIZE; i++) {
-    perm = perm * i;                              // Calculate factorial: perm = i!
-    PermValue[i] = perm;                          // Store current factorial value
-    SumPermValue[i] = SumPermValue[i - 1] + perm; // Calculate cumulative factorial sum
-  }
-
-  // Print i, permvalue, SumPermvalue
-  for (i = 1; i <= PERM_SIZE; i++) {
-    printf("\n%u !, %llu, sigma %llu", i, PermValue[i], SumPermValue[i]);
-  }
-
-  for (i = 0; i < 100; i++)
-    if (ProcessCount[i] > 0)
-      printf("\n [Line %u]%llu", i, ProcessCount[i]);
+    // Debug info logic preserved
+    unsigned long long perm = 1;
+    unsigned long long PermValue[PERM_SIZE + 1] = {0};
+    unsigned long long SumPermValue[PERM_SIZE + 1] = {0};
+    PermValue[0] = 1;
+    SumPermValue[0] = 0;
+    for (int k = 1; k <= PERM_SIZE; k++) {
+        perm = perm * k;
+        PermValue[k] = perm;
+        SumPermValue[k] = SumPermValue[k - 1] + perm;
+    }
+    for (int k = 1; k <= PERM_SIZE; k++) {
+        printf("\n%u !, %llu, sigma %llu", k, PermValue[k], SumPermValue[k]);
+    }
 #endif
 
-  return 0;
-
+    return 0;
 }