Update LexCHA.cpp

Author: Yusheng-Hu

FullPermutation/LexCHA.cpp

@@ -1,7 +1,10 @@
 /**
  * Official Implementation of LexCHA Indexing Algorithms
  * Author: Yusheng Hu
- * Final Version: Optimized for GitHub Actions / GCC 13+
+ * Research: A Divide-and-Conquer Engine for Lexicographical Permutations
+ * * Note: This version is optimized for GCC 13+ under -O3 -march=native.
+ * It includes strict memory alignment to prevent SIMD stringop-overflow 
+ * warnings and strongly prevents dead-code elimination during standard benchmarks.
  */
 
 #include <iostream>
@@ -18,29 +21,36 @@ constexpr int TAIL_DEPTH = 5;
 constexpr int FLAT_STEPS = 119;
 constexpr int XMM_LANES = 16;
 
+// Align LUT to 16-byte boundary for SIMD compatibility
 alignas(16) uint8_t flat_lut_N5[FLAT_STEPS][XMM_LANES];
 
-// ── 1. Manual permutation: Uses aligned buffer to satisfy GCC safety checks ──
+// ── 1. Manual Permutation ────────────────────────────────────────────
+// Uses 16-byte aligned buffers to satisfy GCC's aggressive SIMD safety checks
+// and avoid -Wstringop-overflow warnings during precomputation.
 void next_perm_manual(uint8_t* p, int n) {
     int i = n - 1;
     while (i > 0 && p[i - 1] >= p[i]) i--;
+    
     if (i <= 0) {
         alignas(16) uint8_t temp[16];
-        for(int k=0; k<n; ++k) temp[k] = p[n-1-k];
-        for(int k=0; k<n; ++k) p[k] = temp[k];
+        for(int k = 0; k < n; ++k) temp[k] = p[n - 1 - k];
+        for(int k = 0; k < n; ++k) p[k] = temp[k];
         return;
     }
+    
     int j = n - 1;
     while (p[j] <= p[i - 1]) j--;
     std::swap(p[i - 1], p[j]);
 
     alignas(16) uint8_t tail[16];
     int tail_len = n - i;
-    for(int k=0; k<tail_len; ++k) tail[k] = p[n-1-k];
-    for(int k=0; k<tail_len; ++k) p[i+k] = tail[k];
+    for(int k = 0; k < tail_len; ++k) tail[k] = p[n - 1 - k];
+    for(int k = 0; k < tail_len; ++k) p[i + k] = tail[k];
 }
 
+// ── Precomputation ───────────────────────────────────────────────────
 void precompute_only_flat_lut_N5() {
+    // Declared as 16 bytes to ensure SIMD boundary safety
     alignas(16) uint8_t P[16]; 
     for (int i = 0; i < TAIL_DEPTH; ++i) P[i] = i;
 
@@ -57,7 +67,7 @@ void precompute_only_flat_lut_N5() {
     }
 }
 
-// ── 2. Accelerated engine ──────────────────────────────────────────
+// ── 2. Accelerated Engine ────────────────────────────────────────────
 unsigned long long benchmark_accelerated(int N) {
     std::vector<int> D(N);
     for(int i = 0; i < N; ++i) D[i] = i;
@@ -89,35 +99,57 @@ unsigned long long benchmark_accelerated(int N) {
     return total_count;
 }
 
-// ── 3. Main driver: Output formatted for AWK ─────────────────────────
+// ── 3. Main Driver ───────────────────────────────────────────────────
 int main(int argc, char* argv[]) {
     if (argc < 2) return 1;
     int N = std::atoi(argv[1]);
 
     precompute_only_flat_lut_N5();
 
-    // Standard baseline
+    // --- Benchmark 1: Standard Method ---
+    // Creating a real permutation loop to prevent GCC from eliminating
+    // the code block via Dead Code Elimination under -O3.
+    std::vector<int> V(N);
+    for(int i = 0; i < N; ++i) V[i] = i;
+    
     auto s1 = std::chrono::high_resolution_clock::now();
-    unsigned long long c1 = 1; for(int i=1; i<=N; ++i) c1 *= i;
+    unsigned long long c1 = 0;
+    do {
+        c1++;
+    } while (std::next_permutation(V.begin(), V.end()));
     auto e1 = std::chrono::high_resolution_clock::now();
+    
     double d1 = std::chrono::duration<double>(e1 - s1).count();
-    if(d1 < 1e-9) d1 = 1e-9; 
+    if (d1 < 1e-9) d1 = 1e-9; // Prevent division by zero
 
-    // Accelerated run
+    // --- Benchmark 2: Accelerated Method ---
     auto s2 = std::chrono::high_resolution_clock::now();
     unsigned long long c2 = benchmark_accelerated(N);
     auto e2 = std::chrono::high_resolution_clock::now();
+    
     double d2 = std::chrono::duration<double>(e2 - s2).count();
-    if(d2 < 1e-9) d2 = 1e-9;
+    if (d2 < 1e-9) d2 = 1e-9;
+
+    // --- Sanity Check ---
+    // This check guarantees the compiler MUST evaluate c1 and c2, 
+    // further enforcing that the loops actually run.
+    if (c1 != c2) {
+        std::cerr << "Error: Count mismatch! Std: " << c1 << " Acc: " << c2 << std::endl;
+        return 1;
+    }
+
+    // --- Output formatting for AWK script ---
+    // Target columns: N | Std(s) | Acc(s) | Std_ns/perm | Acc_ns/perm | Speedup
+    double ns_std = (d1 * 1e9) / c1;
+    double ns_acc = (d2 * 1e9) / c2;
+    double speedup = d1 / d2;
 
-    // Use space-separated values for perfect AWK parsing
-    // Format: N Std(s) Acc(s) Std_ns/perm Acc_ns/perm Speedup
     std::cout << N << " " 
               << std::fixed << std::setprecision(6) << d1 << " " 
               << d2 << " " 
-              << (d1 * 1e9) / c1 << " " 
-              << (d2 * 1e9) / c2 << " " 
-              << d1/d2 << std::endl;
+              << ns_std << " " 
+              << ns_acc << " " 
+              << speedup << std::endl;
 
     return 0;
 }