arm aarch64 finaly compile and work fine

Author: at0m741

CMakeLists.txt

@@ -10,32 +10,39 @@ option(BUILD_PLUGINS "Build Clang/LLVM plugins" ON)
 option(BUILD_TESTS "Build test executables" ON)
 option(BUILD_PYBIND "Build Python bindings" OFF)
 option(USE_CUDA "Enable CUDA kernels (requires nvcc)" OFF)
+option(USE_CBLAS "Enable BLAS" ON)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-message(STATUS "Detecting architecture...")
+if(APPLE)
+    list(APPEND CMAKE_PREFIX_PATH "/opt/local" "/opt/local/libexec/llvm-20")
+    include_directories("/opt/local/include")
+    link_directories("/opt/local/lib")
+    link_directories("/opt/local/libexec/llvm-20/lib")
+    
+    find_library(ACCELERATE_LIB Accelerate)
+    if(ACCELERATE_LIB)
+        link_libraries(${ACCELERATE_LIB})
+        add_compile_definitions(TENSORIUM_USE_CBLAS)
+    endif()
+endif()
 
 if (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
-    message(STATUS "→ Building for x86_64 (AVX/AVX2/AVX512 enabled)")
     add_compile_definitions(TENSORIUM_X86)
     add_compile_options(-mavx2 -mfma)
 elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|aarch64")
-    message(STATUS "→ Building for ARM64 / Apple Silicon (NEON enabled)")
     add_compile_definitions(TENSORIUM_ARM)
 else()
-    message(WARNING "→ Unknown architecture: ${CMAKE_SYSTEM_PROCESSOR}, using scalar fallback.")
     add_compile_definitions(TENSORIUM_FALLBACK)
 endif()
 
 find_library(NUMA_LIB numa)
 if (NUMA_LIB)
-    message(STATUS "→ libnuma detected: enabling NUMA-aware allocation")
     add_compile_definitions(USE_NUMA)
     set(HAVE_NUMA TRUE)
 else()
-    message(WARNING "libnuma not found: NUMA support disabled")
     set(HAVE_NUMA FALSE)
 endif()
 
@@ -47,24 +54,18 @@ execute_process(
 )
 
 if (NOT GPU_NAME STREQUAL "none")
-  message(STATUS "Detected NVIDIA GPU: ${GPU_NAME}")
   add_compile_definitions(TENSORIUM_GPU_PRESENT)
-else()
-  message(WARNING "No NVIDIA GPU detected or nvidia-smi missing")
 endif()
 
 if (USE_CUDA)
   if (NOT CUDAToolkit_FOUND)
     message(FATAL_ERROR "USE_CUDA=ON but CUDA toolkit not found")
   endif()
 
-  message(STATUS "CUDA toolkit found at: ${CUDAToolkit_ROOT}")
-  message(STATUS "→ Version: ${CUDAToolkit_VERSION}")
   add_compile_definitions(TENSORIUM_CUDA)
 
   enable_language(CUDA)
   set(CMAKE_CUDA_COMPILER "${CUDAToolkit_NVCC_EXECUTABLE}")
-  message(STATUS "Using NVCC for CUDA compilation: ${CMAKE_CUDA_COMPILER}")
 
   set(CMAKE_CUDA_ARCHITECTURES 61 70 75 80 86 90)
   add_compile_definitions(TENSORIUM_CUDA_ARCH=${CMAKE_CUDA_ARCHITECTURES})
@@ -75,31 +76,25 @@ if (USE_CUDA)
 
   include_directories(${CUDAToolkit_INCLUDE_DIRS})
   link_directories(${CUDAToolkit_LIBRARY_DIR})
-
-  message(STATUS "→ CUDA architectures: ${CMAKE_CUDA_ARCHITECTURES}")
 else()
-  message(STATUS "CUDA support disabled (USE_CUDA=OFF)")
   add_compile_definitions(TENSORIUM_NO_CUDA)
 endif()
 
 include_directories(${CMAKE_SOURCE_DIR}/Includes)
 
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64" OR CMAKE_SYSTEM_PROCESSOR MATCHES "amd64")
-  message(STATUS "Configuring for x86_64: enabling AVX2/FMA or AVX512")
   set(BASE_FLAGS "-O3 -mtune=native -Wno-ignored-attributes -Rpass-analysis=tensorium-align")
   set(AVX2_FLAGS "-mfma -mavx2")
   set(AVX512_FLAGS "-mfma -mavx512f -mavx512cd")
   if(AVX512)
-    set(CMAKE_CXX_FLAGS "${BASE_FLAGS} ${AVX512_FLAGS}")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${BASE_FLAGS} ${AVX512_FLAGS}")
   else()
-    set(CMAKE_CXX_FLAGS "${BASE_FLAGS} ${AVX2_FLAGS}")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${BASE_FLAGS} ${AVX2_FLAGS}")
   endif()
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64" OR CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
-  message(STATUS "Configuring for ARM64: disabling AVX flags")
-  set(CMAKE_CXX_FLAGS "-O3 -mcpu=apple-m1 -Wno-ignored-attributes")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -mcpu=native -Wno-ignored-attributes")
 else()
-  message(WARNING "Unknown architecture (${CMAKE_SYSTEM_PROCESSOR}); using generic optimization flags.")
-  set(CMAKE_CXX_FLAGS "-O3 -mtune=native")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -mtune=native")
 endif()
 
 if(DEBUG)
@@ -109,16 +104,17 @@ if(VERBOSE)
   add_compile_definitions(VERBOSE)
 endif()
 
-message(STATUS "Detected architecture: ${CMAKE_SYSTEM_PROCESSOR}")
-
 if(APPLE)
   if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64")
-    message(STATUS "Configuring OpenMP manually for macOS ARM64 (Apple Clang)")
-    set(OPENMP_INCLUDE_PATH "/opt/homebrew/opt/libomp/include")
-    set(OPENMP_LIB_PATH "/opt/homebrew/opt/libomp/lib")
+    set(OPENMP_INCLUDE_PATH "/opt/local/include/libomp")
+    set(OPENMP_LIB_PATH "/opt/local/lib/libomp")
     set(OPENMP_LIB "omp")
+    
+    include_directories(${OPENMP_INCLUDE_PATH})
+    link_directories(${OPENMP_LIB_PATH})
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Xpreprocessor -fopenmp")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lomp")
   elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
-    message(STATUS "Using OpenMP for macOS x86_64 (Intel)")
     find_package(OpenMP)
     if(OpenMP_CXX_FOUND)
       set(OPENMP_LIB "OpenMP::OpenMP_CXX")
@@ -132,9 +128,9 @@ else()
 endif()
 
 if (HAVE_NUMA)
-    message(STATUS "→ Linking libnuma to all targets (NUMA-aware allocation enabled)")
     link_libraries(${NUMA_LIB})
 endif()
+
 if(BUILD_PLUGINS)
   add_subdirectory(Plugins)
 endif()

Tests/Matrix/Matrix.cpp

@@ -1,9 +1,18 @@
 #include "../test.hpp"
 using namespace tensorium;
 #include <complex>
-#include <cblas.h>
 #include <fstream>
-
+#include <iostream>
+#include <vector>
+
+// --- PROTECTION DU HEADER ---
+#ifdef TENSORIUM_USE_CBLAS
+#    ifdef __APPLE__
+#        include <Accelerate/Accelerate.h>
+#    else
+#        include <cblas.h>
+#    endif
+#endif
 #define CHECK(expr)                                                                                \
     do {                                                                                           \
         if (!(expr)) {                                                                             \
@@ -37,22 +46,29 @@ int matrix_bench() {
     using namespace tensorium;
 
     std::vector<std::size_t> sizes = {1024, 2048, 4096, 8192, 16384};
-    std::string csv_path = "matrix_bench_results.csv";
+    std::string              csv_path = "matrix_bench_results.csv";
 
     std::ofstream csv(csv_path);
+
+#ifdef TENSORIUM_USE_CBLAS
     csv << "N,Tensorium_GFLOPs,OpenBLAS_GFLOPs,Tensorium_Time(s),OpenBLAS_Time(s),Speedup\n";
+#else
+    csv << "N,Tensorium_GFLOPs,Tensorium_Time(s)\n";
+#endif
 
     std::cout << "Benchmarking GEMM performance...\n";
 
     for (std::size_t N : sizes) {
         Matrix<float> A(N, N);
         Matrix<float> B(N, N);
-        Matrix<float> C_ref(N, N);
         Matrix<float> C_our(N, N);
+#ifdef TENSORIUM_USE_CBLAS
+        Matrix<float> C_ref(N, N);
+#endif
 
 #pragma omp parallel
         {
-            std::mt19937 rng(42 + omp_get_thread_num());
+            std::mt19937                          rng(42 + omp_get_thread_num());
             std::uniform_real_distribution<float> dist(0.0f, 1.0f);
 
 #pragma omp for schedule(static)
@@ -69,15 +85,16 @@ int matrix_bench() {
         C_our = mul_mat(A, B);
         auto t1 = std::chrono::high_resolution_clock::now();
 
-        double elapsed_our = std::chrono::duration<double>(t1 - t0).count();
+        double      elapsed_our = std::chrono::duration<double>(t1 - t0).count();
         long double flops = 2.0L * N * N * N;
-        double gflops_our = static_cast<double>(flops / 1e9L) / elapsed_our;
+        double      gflops_our = static_cast<double>(flops / 1e9L) / elapsed_our;
 
         std::cout << "[Tensorium GEMM]\n";
         std::cout << "Time      : " << elapsed_our << " s\n";
         std::cout << "GFLOP/s   : " << gflops_our << "\n";
         std::cout << "Sample C(0,0): " << C_our(0, 0) << "\n";
 
+#ifdef TENSORIUM_USE_CBLAS
         auto t2 = std::chrono::high_resolution_clock::now();
         cblas_sgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, (int)N, (int)N, (int)N, 1.0f,
                     A.data.data(), (int)N, B.data.data(), (int)N, 0.0f, C_ref.data.data(), (int)N);
@@ -97,19 +114,17 @@ int matrix_bench() {
         std::cout << "BLAS      : " << gflops_blas << " GFLOP/s\n";
         std::cout << "Speedup   : x" << speedup << "\n";
 
-        csv << N << ","
-            << gflops_our << ","
-            << gflops_blas << ","
-            << elapsed_our << ","
-            << elapsed_blas << ","
-            << speedup << "\n";
+        csv << N << "," << gflops_our << "," << gflops_blas << "," << elapsed_our << ","
+            << elapsed_blas << "," << speedup << "\n";
+#else
+        csv << N << "," << gflops_our << "," << elapsed_our << "\n";
+#endif
     }
 
     csv.close();
     std::cout << "\nResults written to: " << csv_path << "\n";
     return 0;
 }
-
 int matrix_tests() {
     using Mat = Matrix<float>;
     using Vec = Vector<float>;
@@ -279,7 +294,7 @@ int matrix_tests() {
     Cc.scl(2.0f);
     Cc = tensorium::mul_mat(Ac, Bc);
     std::cout << "✅ add_mat on complex<float> passed.\n";
-    matrix_bench();
+    // matrix_bench();
 
     Mat A2(2, 2);
     A2(0, 0) = 1;

Tests/main.cpp

@@ -7,11 +7,11 @@ using namespace tensorium;
 int main() {
 // #pragma tensorium dispatch
 
-	// deriv_test();	
-	// linear_solver_test();
+	deriv_test();	
+	linear_solver_test();
 	matrix_tests();
-	// tensor_test();
-	// vector_tests();
-	// deriv_test_spectral_fft();
+	tensor_test();
+	vector_tests();
+	deriv_test_spectral_fft();
 	return 0;
 }