CMakeLists.txt

cmake_minimum_required(VERSION 3.14)

option(NEUROFLOW_USE_CUDA "Enable CUDA/cuBLAS backend" OFF)

if(NEUROFLOW_USE_CUDA)
    project(neuroflow_core VERSION 1.0.0 LANGUAGES CXX CUDA)
else()
    project(neuroflow_core VERSION 1.0.0 LANGUAGES CXX)
endif()

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

option(NEUROFLOW_BUILD_TESTS "Build unit tests" OFF)
option(NEUROFLOW_BUILD_PYTHON "Build Python bindings" OFF)
option(NEUROFLOW_USE_AVX2 "Enable AVX2 SIMD" ON)
option(NEUROFLOW_USE_BLAS "Use external BLAS (OpenBLAS/MKL) for GEMM" ON)
option(NEUROFLOW_USE_AMP "Enable mixed precision training (FP16/BF16)" OFF)

if(MSVC)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /GR /EHsc /utf-8")
    if(NEUROFLOW_USE_AVX2)
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:AVX2")
        message(STATUS "AVX2 SIMD enabled (MSVC)")
    endif()
    set(CMAKE_CXX_FLAGS_RELEASE "/O2 /DNDEBUG /GL")
    set(CMAKE_CXX_FLAGS_DEBUG "/Od /Zi /DDEBUG")
    find_package(OpenMP)
else()
    find_package(OpenMP REQUIRED)

    if(NEUROFLOW_USE_AVX2)
        include(CheckCXXCompilerFlag)
        check_cxx_compiler_flag("-mavx2" COMPILER_SUPPORTS_AVX2)
        if(COMPILER_SUPPORTS_AVX2)
            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx2")
            message(STATUS "AVX2 SIMD enabled")
        else()
            message(STATUS "AVX2 not supported by compiler")
        endif()
    endif()

    set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG -march=native -mtune=native -funroll-loops -ffast-math -ftree-vectorize")
    set(CMAKE_CXX_FLAGS_DEBUG "-g -O0 -DDEBUG")
endif()


add_library(neuroflow_core STATIC
    src/tensor.cpp
    src/model.cpp
    src/weight_io.cpp
    src/tokenizer.cpp
    src/sampling.cpp
    src/causal_lm.cpp
    src/tensor_ops.cpp
    src/generative_model.cpp
    src/rope.cpp
    src/swiglu.cpp
    src/rms_norm.cpp
    src/adamw.cpp
    src/scheduler.cpp
    src/train_lm.cpp
    src/grad_scaler.cpp
    src/sft_train.cpp
    src/dpo_train.cpp
)

if(NEUROFLOW_USE_CUDA)
    find_package(CUDAToolkit REQUIRED)
    if(CUDAToolkit_VERSION VERSION_LESS "11.0")
        message(FATAL_ERROR "CUDA >= 11.0 required, found ${CUDAToolkit_VERSION}")
    endif()
    target_compile_definitions(neuroflow_core PUBLIC USE_CUDA)
    target_include_directories(neuroflow_core PUBLIC ${CUDAToolkit_INCLUDE_DIRS})
    target_link_libraries(neuroflow_core PUBLIC CUDA::cudart CUDA::cublas)
    target_sources(neuroflow_core PRIVATE src/cuda_context.cpp)
    set_source_files_properties(src/cuda_context.cpp PROPERTIES LANGUAGE CUDA)
    target_compile_options(neuroflow_core PRIVATE
        $<$<COMPILE_LANGUAGE:CUDA>:--generate-code=arch=compute_80,code=[sm_80,compute_80]>
        $<$<COMPILE_LANGUAGE:CUDA>:--expt-relaxed-constexpr>
        $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>
    )
    set(NEUROFLOW_CUDA_FOUND TRUE)
    message(STATUS "CUDA backend enabled: ${CUDAToolkit_VERSION}")
else()
    set(NEUROFLOW_CUDA_FOUND FALSE)
endif()

target_include_directories(neuroflow_core PUBLIC
    ${CMAKE_CURRENT_SOURCE_DIR}/include
    ${CMAKE_CURRENT_SOURCE_DIR}/src
)

target_compile_definitions(neuroflow_core PRIVATE
    $<$<CONFIG:DEBUG>:DEBUG>
)

if(NEUROFLOW_USE_BLAS)
    find_package(BLAS)
    if(BLAS_FOUND)
        target_compile_definitions(neuroflow_core PUBLIC USE_CBLAS)
        target_link_libraries(neuroflow_core PUBLIC ${BLAS_LIBRARIES})
        if(BLAS_INCLUDE_DIRS)
            target_include_directories(neuroflow_core PUBLIC ${BLAS_INCLUDE_DIRS})
        endif()
        set(NEUROFLOW_BLAS_FOUND TRUE)
        message(STATUS "External BLAS found: ${BLAS_LIBRARIES}")
        message(STATUS "  NOTE: Set OPENBLAS_NUM_THREADS=1 at runtime to avoid thread oversubscription with OpenMP")
    else()
        set(OPENBLAS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/openblas")
        if(EXISTS "${OPENBLAS_DIR}/include/cblas.h" AND EXISTS "${OPENBLAS_DIR}/lib/libscipy_openblas.lib")
            target_compile_definitions(neuroflow_core PUBLIC USE_CBLAS)
            target_include_directories(neuroflow_core PUBLIC "${OPENBLAS_DIR}/include")
            target_link_libraries(neuroflow_core PUBLIC "${OPENBLAS_DIR}/lib/libscipy_openblas.lib")
            set(NEUROFLOW_BLAS_FOUND TRUE)
            message(STATUS "Using bundled OpenBLAS from: ${OPENBLAS_DIR}")
            message(STATUS "  NOTE: Set OPENBLAS_NUM_THREADS=1 at runtime to avoid thread oversubscription with OpenMP")
        else()
            set(NEUROFLOW_BLAS_FOUND FALSE)
            message(STATUS "External BLAS not found, using built-in GEMM")
        endif()
    endif()
else()
    set(NEUROFLOW_BLAS_FOUND FALSE)
endif()

if(NEUROFLOW_USE_AMP)
    if(NOT NEUROFLOW_USE_CUDA)
        message(WARNING "NEUROFLOW_USE_AMP requires CUDA, enabling CUDA automatically")
        set(NEUROFLOW_USE_CUDA ON)
    endif()
    target_compile_definitions(neuroflow_core PUBLIC NEUROFLOW_USE_AMP)
    message(STATUS "Mixed precision training (AMP) enabled")
endif()

if(OpenMP_CXX_FOUND)
    target_link_libraries(neuroflow_core PUBLIC OpenMP::OpenMP_CXX)
endif()

add_executable(neuroflow_train_v2 src/train_v2.cpp)
target_link_libraries(neuroflow_train_v2 PRIVATE neuroflow_core)
if(OpenMP_CXX_FOUND)
    target_link_libraries(neuroflow_train_v2 PRIVATE OpenMP::OpenMP_CXX)
endif()


add_executable(neuroflow_infer_v2 src/infer_v2.cpp)
target_link_libraries(neuroflow_infer_v2 PRIVATE neuroflow_core)
if(OpenMP_CXX_FOUND)
    target_link_libraries(neuroflow_infer_v2 PRIVATE OpenMP::OpenMP_CXX)
endif()

add_executable(neuroflow_sft src/sft_main.cpp)
target_link_libraries(neuroflow_sft PRIVATE neuroflow_core)
if(OpenMP_CXX_FOUND)
    target_link_libraries(neuroflow_sft PRIVATE OpenMP::OpenMP_CXX)
endif()

add_executable(neuroflow_dpo src/dpo_main.cpp)
target_link_libraries(neuroflow_dpo PRIVATE neuroflow_core)
if(OpenMP_CXX_FOUND)
    target_link_libraries(neuroflow_dpo PRIVATE OpenMP::OpenMP_CXX)
endif()

if(NEUROFLOW_BUILD_TESTS)
    enable_testing()

    set(NEUROFLOW_TEST_INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/tests)

    add_executable(neuroflow_test_lm tests/test_lm_pathway.cpp)
    target_link_libraries(neuroflow_test_lm PRIVATE neuroflow_core)
    target_include_directories(neuroflow_test_lm PRIVATE ${NEUROFLOW_TEST_INCLUDE})
    add_test(NAME lm_pathway_test COMMAND neuroflow_test_lm)

    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_tensor.cpp)
        add_executable(neuroflow_tensor_test tests/test_tensor.cpp)
        target_link_libraries(neuroflow_tensor_test PRIVATE neuroflow_core)
        target_include_directories(neuroflow_tensor_test PRIVATE ${NEUROFLOW_TEST_INCLUDE})
        add_test(NAME tensor_test COMMAND neuroflow_tensor_test)
    endif()

    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_model.cpp)
        add_executable(neuroflow_model_test tests/test_model.cpp)
        target_link_libraries(neuroflow_model_test PRIVATE neuroflow_core)
        target_include_directories(neuroflow_model_test PRIVATE ${NEUROFLOW_TEST_INCLUDE})
        add_test(NAME model_test COMMAND neuroflow_model_test)
    endif()

    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_rope.cpp)
        add_executable(neuroflow_test_rope tests/test_rope.cpp)
        target_link_libraries(neuroflow_test_rope PRIVATE neuroflow_core)
        target_include_directories(neuroflow_test_rope PRIVATE ${NEUROFLOW_TEST_INCLUDE})
        add_test(NAME rope_test COMMAND neuroflow_test_rope)
    endif()

    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_swiglu.cpp)
        add_executable(neuroflow_test_swiglu tests/test_swiglu.cpp)
        target_link_libraries(neuroflow_test_swiglu PRIVATE neuroflow_core)
        target_include_directories(neuroflow_test_swiglu PRIVATE ${NEUROFLOW_TEST_INCLUDE})
        add_test(NAME swiglu_test COMMAND neuroflow_test_swiglu)
    endif()

    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_rms_norm.cpp)
        add_executable(neuroflow_test_rms_norm tests/test_rms_norm.cpp)
        target_link_libraries(neuroflow_test_rms_norm PRIVATE neuroflow_core)
        target_include_directories(neuroflow_test_rms_norm PRIVATE ${NEUROFLOW_TEST_INCLUDE})
        add_test(NAME rms_norm_test COMMAND neuroflow_test_rms_norm)
    endif()

    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_adamw.cpp)
        add_executable(neuroflow_test_adamw tests/test_adamw.cpp)
        target_link_libraries(neuroflow_test_adamw PRIVATE neuroflow_core)
        target_include_directories(neuroflow_test_adamw PRIVATE ${NEUROFLOW_TEST_INCLUDE})
        add_test(NAME adamw_test COMMAND neuroflow_test_adamw)
    endif()

    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_scheduler.cpp)
        add_executable(neuroflow_test_scheduler tests/test_scheduler.cpp)
        target_link_libraries(neuroflow_test_scheduler PRIVATE neuroflow_core)
        target_include_directories(neuroflow_test_scheduler PRIVATE ${NEUROFLOW_TEST_INCLUDE})
        add_test(NAME scheduler_test COMMAND neuroflow_test_scheduler)
    endif()

    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_gqa.cpp)
        add_executable(neuroflow_test_gqa tests/test_gqa.cpp)
        target_link_libraries(neuroflow_test_gqa PRIVATE neuroflow_core)
        target_include_directories(neuroflow_test_gqa PRIVATE ${NEUROFLOW_TEST_INCLUDE})
        add_test(NAME gqa_test COMMAND neuroflow_test_gqa)
    endif()

    message(STATUS "Unit tests enabled (built-in test framework)")
endif()

install(TARGETS neuroflow_core
    ARCHIVE DESTINATION lib
    LIBRARY DESTINATION lib
)

install(DIRECTORY include/neuroflow
    DESTINATION include
)

message(STATUS "")
message(STATUS "NeuroFlow Core Build Configuration:")
message(STATUS "  Version:        ${PROJECT_VERSION}")
message(STATUS "  C++ Standard:   ${CMAKE_CXX_STANDARD}")
message(STATUS "  Build Type:     ${CMAKE_BUILD_TYPE}")
message(STATUS "  AVX2:           ${NEUROFLOW_USE_AVX2}")
message(STATUS "  AMP:            ${NEUROFLOW_USE_AMP}")
message(STATUS "  Tests:          ${NEUROFLOW_BUILD_TESTS}")
message(STATUS "  Python:         ${NEUROFLOW_BUILD_PYTHON}")
message(STATUS "  OpenMP:         ${OpenMP_CXX_FOUND}")
message(STATUS "  BLAS:           ${NEUROFLOW_BLAS_FOUND}")
message(STATUS "  CUDA:           ${NEUROFLOW_CUDA_FOUND}")