Update LexCHA.cpp

Author: Yusheng-Hu

FullPermutation/LexCHA.cpp

@@ -1,8 +1,7 @@
 /**
  * Official Implementation of LexCHA Indexing Algorithms
- * Author: Yusheng Hu
- * Research: A Divide-and-Conquer Engine for Lexicographical Permutations
- * * Note: Added <chrono> to resolve time-related compilation errors.
+ * Final Fix: Using 16-byte aligned buffer for manual permutation to 
+ * satisfy GCC's aggressive optimization safety checks.
  */
 
 #include <iostream>
@@ -11,33 +10,41 @@
 #include <immintrin.h>
 #include <cstring>
 #include <algorithm>
-#include <cstdint> // Required for uint8_t
-#include <chrono>  // Required for std::chrono
+#include <cstdint>
+#include <chrono>
 
-// ── Architecture Configuration ───────────────────────────────────────
 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. Precompute: Manual permutation ────────────────────────────────
+// ── 1. Manual permutation with 16-byte safe buffer ───────────────────
 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) {
-        std::reverse(p, p + n);
+        // Use a local 16-byte aligned array to satisfy the compiler's 
+        // need for safety during reverse operations.
+        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];
         return;
     }
     int j = n - 1;
     while (p[j] <= p[i - 1]) j--;
     std::swap(p[i - 1], p[j]);
-    std::reverse(p + i, p + n);
+    
+    // Reverse the tail using the same safe logic
+    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];
 }
 
 void precompute_only_flat_lut_N5() {
-    uint8_t P[TAIL_DEPTH];
+    // Declaring 16 bytes instead of 5 to align with SIMD register sizes
+    alignas(16) uint8_t P[16]; 
     for (int i = 0; i < TAIL_DEPTH; ++i) P[i] = i;
 
     for (int step = 0; step < FLAT_STEPS; ++step) {
@@ -58,7 +65,6 @@ unsigned long long benchmark_accelerated(int N) {
     std::vector<int> D(N);
     for(int i = 0; i < N; ++i) D[i] = i;
 
-    // Aligned buffer to ensure safe memory access for SIMD
     alignas(16) uint8_t buffer[32] = {0}; 
     std::memcpy(buffer, &D[N - TAIL_DEPTH], TAIL_DEPTH * sizeof(int));
     __m128i p_reg = _mm_load_si128((__m128i*)buffer);
@@ -86,19 +92,16 @@ unsigned long long benchmark_accelerated(int N) {
     return total_count;
 }
 
-// ── 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();
-
+    
     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();
     std::cout << "N=" << N << " | Acc(s): " << d2 << " | Count: " << c2 << std::endl;
-
     return 0;
 }