CMakeLists.txt

cmake_minimum_required(VERSION 3.16)
project(TraceSmith 
    VERSION 0.11.1
    DESCRIPTION "Cross-platform GPU Profiling & Replay System"
    LANGUAGES CXX
)

# C++ Standard
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

# Windows-specific settings
if(WIN32)
    # Prevent min/max macros from conflicting with std::min/std::max
    add_definitions(-DNOMINMAX)
    # Suppress some common MSVC warnings
    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
endif()

# Build options
option(TRACESMITH_BUILD_TESTS "Build unit tests" ON)
option(TRACESMITH_BUILD_EXAMPLES "Build examples" ON)
option(TRACESMITH_BUILD_CLI "Build CLI tools" ON)
option(TRACESMITH_BUILD_PYTHON "Build Python bindings" OFF)
option(TRACESMITH_ENABLE_CUDA "Enable CUDA/CUPTI support" OFF)
option(TRACESMITH_ENABLE_ROCM "Enable ROCm support" OFF)
option(TRACESMITH_ENABLE_METAL "Enable Metal support" OFF)
option(TRACESMITH_ENABLE_MACA "Enable MetaX MACA/MCPTI support" OFF)
option(TRACESMITH_ENABLE_ASCEND "Enable Huawei Ascend/CANN support" OFF)
option(TRACESMITH_ENABLE_TRACY "Enable Tracy Profiler integration" ON)
option(TRACESMITH_USE_LIBUNWIND "Use libunwind for call stack capture" ON)
option(TRACESMITH_USE_PERFETTO_SDK "Use Perfetto SDK for protobuf export" OFF)

# Output directories
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)

# Compiler warnings
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang|AppleClang")
    add_compile_options(-Wall -Wextra -Wpedantic)
endif()

# Include directories
include_directories(${CMAKE_SOURCE_DIR}/include)

# Third-party dependencies
add_subdirectory(third_party)

# GPU Platform Detection
list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)

# CUDA/CUPTI Support
if(TRACESMITH_ENABLE_CUDA)
    find_package(CUPTI)
    if(CUPTI_FOUND)
        message(STATUS "CUPTI found: ${CUPTI_VERSION}")
        message(STATUS "  Include: ${CUPTI_INCLUDE_DIRS}")
        message(STATUS "  Library: ${CUPTI_LIBRARIES}")
        add_definitions(-DTRACESMITH_ENABLE_CUDA)
    else()
        message(WARNING "CUPTI not found, CUDA support disabled")
        set(TRACESMITH_ENABLE_CUDA OFF)
    endif()
endif()

# AMD ROCm Support
if(TRACESMITH_ENABLE_ROCM)
    if(NOT ROCM_PATH)
        # Try to find ROCm SDK in common locations
        foreach(ROCM_DIR "/opt/rocm" "/opt/rocm-6.0.0" "/opt/rocm-5.7.0" "$ENV{ROCM_PATH}")
            if(EXISTS "${ROCM_DIR}/include/hip/hip_runtime.h")
                set(ROCM_PATH "${ROCM_DIR}" CACHE PATH "Path to ROCm SDK")
                break()
            endif()
        endforeach()
    endif()
    
    if(ROCM_PATH AND EXISTS "${ROCM_PATH}/include/hip/hip_runtime.h")
        message(STATUS "ROCm SDK found at: ${ROCM_PATH}")
        
        # Find HIP runtime library
        find_library(HIP_LIBRARY amdhip64
            PATHS ${ROCM_PATH}/lib ${ROCM_PATH}/lib64
            NO_DEFAULT_PATH)
        
        # Find roctracer library
        find_library(ROCTRACER_LIBRARY roctracer64
            PATHS ${ROCM_PATH}/lib ${ROCM_PATH}/lib64
            NO_DEFAULT_PATH)
        
        if(HIP_LIBRARY AND ROCTRACER_LIBRARY)
            message(STATUS "  HIP Library: ${HIP_LIBRARY}")
            message(STATUS "  roctracer Library: ${ROCTRACER_LIBRARY}")
            add_definitions(-DTRACESMITH_ENABLE_ROCM)
            set(ROCM_INCLUDE_DIRS ${ROCM_PATH}/include)
            set(ROCM_LIBRARIES ${HIP_LIBRARY} ${ROCTRACER_LIBRARY})
        else()
            message(WARNING "ROCm libraries not found, ROCm support disabled")
            set(TRACESMITH_ENABLE_ROCM OFF)
        endif()
    else()
        message(WARNING "ROCm SDK not found, ROCm support disabled. Set ROCM_PATH to the correct path.")
        set(TRACESMITH_ENABLE_ROCM OFF)
    endif()
endif()

# MetaX MACA/MCPTI Support
if(TRACESMITH_ENABLE_MACA)
    if(NOT MACA_ROOT)
        # Try to find MACA SDK in common locations
        foreach(MACA_PATH "/opt/maca-3.0.0" "/opt/maca" "/usr/local/maca")
            if(EXISTS "${MACA_PATH}/include/mcpti/mcpti.h")
                set(MACA_ROOT "${MACA_PATH}" CACHE PATH "Path to MACA SDK")
                break()
            endif()
        endforeach()
    endif()
    
    if(MACA_ROOT AND EXISTS "${MACA_ROOT}/include/mcpti/mcpti.h")
        message(STATUS "MACA SDK found at: ${MACA_ROOT}")
        add_definitions(-DTRACESMITH_ENABLE_MACA)
    else()
        message(WARNING "MACA SDK not found, MetaX support disabled. Set MACA_ROOT to the correct path.")
        set(TRACESMITH_ENABLE_MACA OFF)
    endif()
endif()

# Huawei Ascend/CANN Support
if(TRACESMITH_ENABLE_ASCEND)
    if(NOT ASCEND_HOME)
        # Try to find Ascend SDK in common locations
        foreach(ASCEND_PATH "/usr/local/Ascend/ascend-toolkit/latest" "/usr/local/Ascend" "$ENV{ASCEND_HOME}")
            if(EXISTS "${ASCEND_PATH}/include/acl/acl.h")
                set(ASCEND_HOME "${ASCEND_PATH}" CACHE PATH "Path to Ascend CANN SDK")
                break()
            endif()
        endforeach()
    endif()
    
    if(ASCEND_HOME AND EXISTS "${ASCEND_HOME}/include/acl/acl.h")
        message(STATUS "Ascend CANN SDK found at: ${ASCEND_HOME}")
        
        # Find ACL library
        find_library(ACL_LIBRARY ascendcl
            PATHS ${ASCEND_HOME}/lib64 ${ASCEND_HOME}/aarch64-linux/lib64
            NO_DEFAULT_PATH)
        
        if(ACL_LIBRARY)
            message(STATUS "  ACL Library: ${ACL_LIBRARY}")
            add_definitions(-DTRACESMITH_ENABLE_ASCEND)
            set(ASCEND_INCLUDE_DIRS ${ASCEND_HOME}/include)
            set(ASCEND_LIBRARIES ${ACL_LIBRARY})
        else()
            message(WARNING "Ascend ACL library not found, Ascend support disabled")
            set(TRACESMITH_ENABLE_ASCEND OFF)
        endif()
    else()
        message(WARNING "Ascend CANN SDK not found, Ascend support disabled. Set ASCEND_HOME to the correct path.")
        set(TRACESMITH_ENABLE_ASCEND OFF)
    endif()
endif()

# libunwind Support (Cross-platform stack unwinding)
if(TRACESMITH_USE_LIBUNWIND)
    find_package(Libunwind)
    if(LIBUNWIND_FOUND)
        message(STATUS "libunwind found: ${LIBUNWIND_VERSION}")
        message(STATUS "  Include: ${LIBUNWIND_INCLUDE_DIRS}")
        message(STATUS "  Library: ${LIBUNWIND_LIBRARIES}")
        add_definitions(-DTRACESMITH_USE_LIBUNWIND)
    else()
        message(STATUS "libunwind not found, using platform-specific backtrace")
        set(TRACESMITH_USE_LIBUNWIND OFF)
    endif()
endif()

# Perfetto SDK Support (Native protobuf export)
if(TRACESMITH_USE_PERFETTO_SDK)
    set(PERFETTO_SDK_DIR ${CMAKE_SOURCE_DIR}/third_party/perfetto)
    if(EXISTS ${PERFETTO_SDK_DIR}/perfetto.h AND EXISTS ${PERFETTO_SDK_DIR}/perfetto.cc)
        message(STATUS "Perfetto SDK found")
        message(STATUS "  Location: ${PERFETTO_SDK_DIR}")
        add_definitions(-DTRACESMITH_PERFETTO_SDK_ENABLED)
        # Create perfetto library target
        add_library(perfetto_sdk STATIC ${PERFETTO_SDK_DIR}/perfetto.cc)
        target_include_directories(perfetto_sdk PUBLIC ${PERFETTO_SDK_DIR})
        # Perfetto SDK requires C++11 minimum, we use C++17
        target_compile_features(perfetto_sdk PUBLIC cxx_std_17)
        # Disable warnings for third-party code
        if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang|AppleClang")
            target_compile_options(perfetto_sdk PRIVATE -w)
        elseif(MSVC)
            target_compile_options(perfetto_sdk PRIVATE /w)
        endif()
    else()
        message(WARNING "Perfetto SDK files not found at ${PERFETTO_SDK_DIR}")
        message(WARNING "  Looking for: perfetto.h and perfetto.cc")
        message(WARNING "  Disabling Perfetto SDK support")
        set(TRACESMITH_USE_PERFETTO_SDK OFF)
    endif()
endif()

# Metal Support (macOS/iOS)
if(TRACESMITH_ENABLE_METAL)
    if(APPLE)
        find_library(METAL_LIBRARY Metal)
        find_library(FOUNDATION_LIBRARY Foundation)
        if(METAL_LIBRARY AND FOUNDATION_LIBRARY)
            message(STATUS "Metal framework found")
            message(STATUS "  Metal: ${METAL_LIBRARY}")
            message(STATUS "  Foundation: ${FOUNDATION_LIBRARY}")
            add_definitions(-DTRACESMITH_ENABLE_METAL)
        else()
            message(WARNING "Metal framework not found, Metal support disabled")
            set(TRACESMITH_ENABLE_METAL OFF)
        endif()
    else()
        message(WARNING "Metal is only available on Apple platforms")
        set(TRACESMITH_ENABLE_METAL OFF)
    endif()
endif()

# Core libraries
add_subdirectory(src/common)
add_subdirectory(src/format)
add_subdirectory(src/capture)
add_subdirectory(src/state)
add_subdirectory(src/replay)
add_subdirectory(src/cluster)

# Tracy integration
if(TRACESMITH_ENABLE_TRACY)
    add_subdirectory(src/tracy)
endif()

# GDB RSP backend (Linux only for now)
option(TRACESMITH_BUILD_GDB "Build GDB RSP backend" ON)
if(TRACESMITH_BUILD_GDB AND UNIX)
    add_subdirectory(src/gdb)
endif()

# CLI tools
if(TRACESMITH_BUILD_CLI)
    add_subdirectory(cli)
endif()

# Tests
if(TRACESMITH_BUILD_TESTS)
    enable_testing()
    add_subdirectory(tests)
endif()

# Examples
if(TRACESMITH_BUILD_EXAMPLES)
    add_subdirectory(examples)
endif()

# Python bindings
if(TRACESMITH_BUILD_PYTHON)
    add_subdirectory(python)
endif()

# Installation
include(GNUInstallDirs)

install(DIRECTORY include/tracesmith
    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)

# Package configuration
include(CMakePackageConfigHelpers)

configure_package_config_file(
    ${CMAKE_SOURCE_DIR}/cmake/TraceSmithConfig.cmake.in
    ${CMAKE_BINARY_DIR}/TraceSmithConfig.cmake
    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/TraceSmith
)

write_basic_package_version_file(
    ${CMAKE_BINARY_DIR}/TraceSmithConfigVersion.cmake
    VERSION ${PROJECT_VERSION}
    COMPATIBILITY SameMajorVersion
)

install(FILES
    ${CMAKE_BINARY_DIR}/TraceSmithConfig.cmake
    ${CMAKE_BINARY_DIR}/TraceSmithConfigVersion.cmake
    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/TraceSmith
)

# Summary
message(STATUS "")
message(STATUS "TraceSmith v${PROJECT_VERSION} Configuration:")
message(STATUS "  Build type:     ${CMAKE_BUILD_TYPE}")
message(STATUS "  Build tests:    ${TRACESMITH_BUILD_TESTS}")
message(STATUS "  Build examples: ${TRACESMITH_BUILD_EXAMPLES}")
message(STATUS "  Build CLI:      ${TRACESMITH_BUILD_CLI}")
message(STATUS "  Build Python:   ${TRACESMITH_BUILD_PYTHON}")
if(CUPTI_FOUND)
    message(STATUS "  CUDA support:   ${TRACESMITH_ENABLE_CUDA} (CUPTI ${CUPTI_VERSION})")
else()
    message(STATUS "  CUDA support:   ${TRACESMITH_ENABLE_CUDA}")
endif()
message(STATUS "  ROCm support:   ${TRACESMITH_ENABLE_ROCM}")
message(STATUS "  Metal support:  ${TRACESMITH_ENABLE_METAL}")
message(STATUS "  MACA support:   ${TRACESMITH_ENABLE_MACA}")
message(STATUS "  Ascend support: ${TRACESMITH_ENABLE_ASCEND}")
message(STATUS "  Tracy support:  ${TRACESMITH_ENABLE_TRACY}")
message(STATUS "  Perfetto SDK:   ${TRACESMITH_USE_PERFETTO_SDK}")
message(STATUS "  libunwind:      ${TRACESMITH_USE_LIBUNWIND}")
message(STATUS "")