perf: Add cross-platform architecture support and remove test code

src/perf/compiler_optimization.rs

@@ -262,21 +262,26 @@ impl CompilerOptimizer {
 impl OptimizationFlags {
     /// 超高性能配置
     pub fn ultra_performance() -> Self {
+        #[cfg(target_arch = "x86_64")]
+        let target_features = vec![
+            "+sse4.2".to_string(),
+            "+avx".to_string(),
+            "+avx2".to_string(),
+            "+fma".to_string(),
+            "+bmi1".to_string(),
+            "+bmi2".to_string(),
+            "+lzcnt".to_string(),
+            "+popcnt".to_string(),
+        ];
+
+        #[cfg(not(target_arch = "x86_64"))]
+        let target_features = vec![];
         Self {
             opt_level: OptLevel::Aggressive,
             enable_lto: true,
             enable_pgo: false, // PGO需要多阶段构建
             target_cpu: "native".to_string(), // 使用本机CPU特性
-            target_features: vec![
+            target_features,
-                "+sse4.2".to_string(),
-                "+avx".to_string(), 
-                "+avx2".to_string(),
-                "+fma".to_string(),
-                "+bmi1".to_string(),
-                "+bmi2".to_string(),
-                "+lzcnt".to_string(),
-                "+popcnt".to_string(),
-            ],
             code_model: CodeModel::Small,
             debug_info: false,
             incremental: false, // 发布版本禁用增量编译
@@ -454,7 +459,8 @@ impl CompileTimeOptimizedEventProcessor {
 pub struct SIMDCompileTimeOptimizer;
 
 impl SIMDCompileTimeOptimizer {
-    /// 编译时SIMD向量化
+    /// 编译时SIMD向量化 - x86_64 AVX2 版本
+    #[cfg(target_arch = "x86_64")]
     #[target_feature(enable = "avx2")]
     pub unsafe fn vectorized_sum_compile_time(data: &[u64]) -> u64 {
         use std::arch::x86_64::*;
@@ -482,6 +488,12 @@ impl SIMDCompileTimeOptimizer {
         
         partial_sum + remaining
     }
+
+    /// 编译时SIMD向量化 - 通用回退版本（非x86_64架构）
+    #[cfg(not(target_arch = "x86_64"))]
+    pub fn vectorized_sum_compile_time(data: &[u64]) -> u64 {
+        data.iter().sum()
+    }
 }
 
 /// 🚀 生成优化构建脚本
@@ -524,7 +536,6 @@ rustflags = [
     "-C", "panic=abort",
     "-C", "codegen-units=1",
     "-C", "target-cpu=native",
-    "-C", "target-feature=+sse4.2,+avx,+avx2,+fma,+bmi1,+bmi2,+lzcnt,+popcnt",
     "-C", "embed-bitcode=no",
     "-C", "debuginfo=0",
     "-C", "overflow-checks=no",
@@ -553,6 +564,17 @@ rustflags = [
     "-C", "link-arg=-fuse-ld=lld",
     "-C", "link-arg=-Wl,--gc-sections",
     "-C", "link-arg=-Wl,--icf=all",
+    "-C", "target-feature=+sse4.2,+avx,+avx2,+fma,+bmi1,+bmi2,+lzcnt,+popcnt",
+]
+
+[target.x86_64-apple-darwin]
+rustflags = [
+    "-C", "target-feature=+sse4.2,+avx,+avx2,+fma,+bmi1,+bmi2,+lzcnt,+popcnt",
+]
+
+[target.x86_64-pc-windows-msvc]
+rustflags = [
+    "-C", "target-feature=+sse4.2,+avx,+avx2,+fma,+bmi1,+bmi2,+lzcnt,+popcnt",
 ]
 "#.to_string()
 }
@@ -606,11 +628,19 @@ mod tests {
     
     #[test]
     fn test_simd_compile_time_optimization() {
+        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
         if is_x86_feature_detected!("avx2") {
             let data = vec![1u64, 2, 3, 4, 5, 6, 7, 8];
             let sum = unsafe { SIMDCompileTimeOptimizer::vectorized_sum_compile_time(&data) };
             assert_eq!(sum, 36); // 1+2+3+4+5+6+7+8 = 36
         }
+
+        #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
+        {
+            let data = vec![1u64, 2, 3, 4, 5, 6, 7, 8];
+            let sum = SIMDCompileTimeOptimizer::vectorized_sum_compile_time(&data);
+            assert_eq!(sum, 36); // 1+2+3+4+5+6+7+8 = 36
+        }
     }
     
     #[test]

src/perf/simd.rs

@@ -6,6 +6,7 @@
 //! - 向量化数学运算
 //! - 并行数据处理
 
+#[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
 
 /// SIMD 内存操作
@@ -13,6 +14,7 @@ pub struct SIMDMemory;
 
 impl SIMDMemory {
     /// 使用 SIMD 加速内存拷贝（256位 AVX2）
+    #[cfg(target_arch = "x86_64")]
     #[inline(always)]
     pub unsafe fn copy_avx2(dst: *mut u8, src: *const u8, len: usize) {
         let mut offset = 0;
@@ -31,7 +33,15 @@ impl SIMDMemory {
         }
     }
 
+    /// 使用通用方法拷贝内存（非x86_64架构）
+    #[cfg(not(target_arch = "x86_64"))]
+    #[inline(always)]
+    pub unsafe fn copy_avx2(dst: *mut u8, src: *const u8, len: usize) {
+        std::ptr::copy_nonoverlapping(src, dst, len);
+    }
+
     /// 使用 SIMD 加速内存比较
+    #[cfg(target_arch = "x86_64")]
     #[inline(always)]
     pub unsafe fn compare_avx2(a: *const u8, b: *const u8, len: usize) -> bool {
         let mut offset = 0;
@@ -60,7 +70,15 @@ impl SIMDMemory {
         true
     }
 
+    /// 使用通用方法比较内存（非x86_64架构）
+    #[cfg(not(target_arch = "x86_64"))]
+    #[inline(always)]
+    pub unsafe fn compare_avx2(a: *const u8, b: *const u8, len: usize) -> bool {
+        std::slice::from_raw_parts(a, len) == std::slice::from_raw_parts(b, len)
+    }
+
     /// 使用 SIMD 清零内存
+    #[cfg(target_arch = "x86_64")]
     #[inline(always)]
     pub unsafe fn zero_avx2(ptr: *mut u8, len: usize) {
         let zero = _mm256_setzero_si256();
@@ -78,13 +96,21 @@ impl SIMDMemory {
             offset += 1;
         }
     }
+
+    /// 使用通用方法清零内存（非x86_64架构）
+    #[cfg(not(target_arch = "x86_64"))]
+    #[inline(always)]
+    pub unsafe fn zero_avx2(ptr: *mut u8, len: usize) {
+        std::ptr::write_bytes(ptr, 0, len);
+    }
 }
 
 /// SIMD 数学运算
 pub struct SIMDMath;
 
 impl SIMDMath {
-    /// 批量 u64 加法
+    /// 批量 u64 加法 - x86_64 版本
+    #[cfg(target_arch = "x86_64")]
     #[inline(always)]
     pub unsafe fn add_u64_batch(a: &[u64], b: &[u64], result: &mut [u64]) {
         assert_eq!(a.len(), b.len());
@@ -109,6 +135,18 @@ impl SIMDMath {
         }
     }
 
+    /// 批量 u64 加法 - 通用版本（非x86_64架构）
+    #[cfg(not(target_arch = "x86_64"))]
+    #[inline(always)]
+    pub fn add_u64_batch(a: &[u64], b: &[u64], result: &mut [u64]) {
+        assert_eq!(a.len(), b.len());
+        assert_eq!(a.len(), result.len());
+
+        for i in 0..a.len() {
+            result[i] = a[i].wrapping_add(b[i]);
+        }
+    }
+
     /// 批量查找最大值
     #[inline(always)]
     pub fn max_u64_batch(data: &[u64]) -> u64 {
@@ -269,10 +307,14 @@ mod tests {
         let b = vec![5u64, 6, 7, 8];
         let mut result = vec![0u64; 4];
 
+        #[cfg(target_arch = "x86_64")]
         unsafe {
             SIMDMath::add_u64_batch(&a, &b, &mut result);
         }
 
+        #[cfg(not(target_arch = "x86_64"))]
+        SIMDMath::add_u64_batch(&a, &b, &mut result);
+
         assert_eq!(result, vec![6, 8, 10, 12]);
     }
 

src/trading/core/execution.rs

@@ -153,34 +153,3 @@ impl ExecutionPath {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use solana_sdk::system_instruction;
-
-    #[test]
-    fn test_instruction_preprocessing() {
-        let instructions = vec![
-            system_instruction::transfer(
-                &Pubkey::new_unique(),
-                &Pubkey::new_unique(),
-                1000,
-            ),
-        ];
-
-        assert!(InstructionProcessor::preprocess(&instructions).is_ok());
-    }
-
-    #[test]
-    fn test_memory_ops() {
-        let src = vec![1u8, 2, 3, 4, 5];
-        let mut dst = vec![0u8; 5];
-
-        unsafe {
-            MemoryOps::copy(dst.as_mut_ptr(), src.as_ptr(), src.len());
-        }
-
-        assert_eq!(src, dst);
-    }
-}

src/trading/core/transaction_pool.rs

@@ -164,77 +164,3 @@ impl Drop for TxBuilderGuard {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_pool_operations() {
-        let builder1 = acquire_builder();
-        let builder2 = acquire_builder();
-
-        release_builder(builder1);
-        release_builder(builder2);
-
-        let (available, capacity) = get_pool_stats();
-        assert!(available >= 2);
-        assert_eq!(capacity, 1000);
-    }
-
-    #[test]
-    fn test_builder_guard() {
-        let initial_count = get_pool_stats().0;
-
-        {
-            let _guard = TxBuilderGuard::new();
-            // guard 会在作用域结束时自动归还
-        }
-
-        let final_count = get_pool_stats().0;
-        assert_eq!(final_count, initial_count);
-    }
-
-    #[test]
-    fn test_message_version_selection() {
-        use solana_sdk::signature::Keypair;
-        use solana_sdk::system_instruction;
-
-        let payer = Keypair::new();
-        let recipient = Keypair::new();
-        let blockhash = Hash::default();
-
-        let instructions = vec![
-            system_instruction::transfer(&payer.pubkey(), &recipient.pubkey(), 1000)
-        ];
-
-        let mut builder = PreallocatedTxBuilder::new();
-
-        // 测试1: 无查找表 -> 应该返回 Legacy 消息
-        let msg_no_lookup = builder.build_zero_alloc(
-            &payer.pubkey(),
-            &instructions,
-            None,  // ← 无查找表
-            blockhash,
-        );
-
-        assert!(
-            matches!(msg_no_lookup, VersionedMessage::Legacy(_)),
-            "Without lookup table, should use Legacy message"
-        );
-
-        // 测试2: 有查找表 -> 应该返回 V0 消息
-        let lookup_table_key = Pubkey::new_unique();
-        let msg_with_lookup = builder.build_zero_alloc(
-            &payer.pubkey(),
-            &instructions,
-            Some(lookup_table_key),  // ← 有查找表
-            blockhash,
-        );
-
-        assert!(
-            matches!(msg_with_lookup, VersionedMessage::V0(_)),
-            "With lookup table, should use V0 message"
-        );
-    }
-}