mirror of
https://github.com/ggerganov/llama.cpp.git
synced 2024-10-30 14:40:16 +01:00
b213227067
It's currently not possible to cross-compile llama.cpp for aarch64 because CMakeLists.txt forces -mcpu=native for that target. -mcpu=native doesn't make sense if your build host is not the target architecture, and clang rejects it for that reason, aborting the build. This can be easily reproduced using the current Android NDK to build for aarch64 on an x86_64 host. If there is not a specific CPU-tuning target for aarch64 then -mcpu should be omitted completely. I think that makes sense, there is not enough variance in the aarch64 instruction set to warrant a fixed -mcpu optimization at this point. And if someone is building natively and wishes to enable any possible optimizations for the host device, then there is already the LLAMA_NATIVE option available. Fixes #495.
518 lines
18 KiB
CMake
518 lines
18 KiB
CMake
cmake_minimum_required(VERSION 3.12) # Don't bump this version for no reason
|
|
project("llama.cpp" C CXX)
|
|
|
|
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
|
|
|
|
if (NOT XCODE AND NOT MSVC AND NOT CMAKE_BUILD_TYPE)
|
|
set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
|
|
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
|
|
endif()
|
|
|
|
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
|
|
|
|
if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
|
|
set(LLAMA_STANDALONE ON)
|
|
|
|
# configure project version
|
|
# TODO
|
|
else()
|
|
set(LLAMA_STANDALONE OFF)
|
|
endif()
|
|
|
|
if (EMSCRIPTEN)
|
|
set(BUILD_SHARED_LIBS_DEFAULT OFF)
|
|
|
|
option(LLAMA_WASM_SINGLE_FILE "llama: embed WASM inside the generated llama.js" ON)
|
|
else()
|
|
if (MINGW)
|
|
set(BUILD_SHARED_LIBS_DEFAULT OFF)
|
|
else()
|
|
set(BUILD_SHARED_LIBS_DEFAULT ON)
|
|
endif()
|
|
endif()
|
|
|
|
|
|
#
|
|
# Option list
|
|
#
|
|
|
|
# general
|
|
option(LLAMA_STATIC "llama: static link libraries" OFF)
|
|
option(LLAMA_NATIVE "llama: enable -march=native flag" OFF)
|
|
option(LLAMA_LTO "llama: enable link time optimization" OFF)
|
|
|
|
# debug
|
|
option(LLAMA_ALL_WARNINGS "llama: enable all compiler warnings" ON)
|
|
option(LLAMA_ALL_WARNINGS_3RD_PARTY "llama: enable all compiler warnings in 3rd party libs" OFF)
|
|
option(LLAMA_GPROF "llama: enable gprof" OFF)
|
|
|
|
# sanitizers
|
|
option(LLAMA_SANITIZE_THREAD "llama: enable thread sanitizer" OFF)
|
|
option(LLAMA_SANITIZE_ADDRESS "llama: enable address sanitizer" OFF)
|
|
option(LLAMA_SANITIZE_UNDEFINED "llama: enable undefined sanitizer" OFF)
|
|
|
|
# instruction set specific
|
|
option(LLAMA_AVX "llama: enable AVX" ON)
|
|
option(LLAMA_AVX2 "llama: enable AVX2" ON)
|
|
option(LLAMA_AVX512 "llama: enable AVX512" OFF)
|
|
option(LLAMA_AVX512_VBMI "llama: enable AVX512-VBMI" OFF)
|
|
option(LLAMA_AVX512_VNNI "llama: enable AVX512-VNNI" OFF)
|
|
option(LLAMA_FMA "llama: enable FMA" ON)
|
|
# in MSVC F16C is implied with AVX2/AVX512
|
|
if (NOT MSVC)
|
|
option(LLAMA_F16C "llama: enable F16C" ON)
|
|
endif()
|
|
|
|
# 3rd party libs
|
|
option(LLAMA_ACCELERATE "llama: enable Accelerate framework" ON)
|
|
option(LLAMA_BLAS "llama: use BLAS" OFF)
|
|
set(LLAMA_BLAS_VENDOR "Generic" CACHE STRING "llama: BLAS library vendor")
|
|
option(LLAMA_CUBLAS "llama: use cuBLAS" OFF)
|
|
set(LLAMA_CUDA_DMMV_X "32" CACHE STRING "llama: x stride for dmmv CUDA kernels")
|
|
set(LLAMA_CUDA_DMMV_Y "1" CACHE STRING "llama: y block size for dmmv CUDA kernels")
|
|
option(LLAMA_CUDA_DMMV_F16 "llama: use 16 bit floats for dmmv CUDA kernels" OFF)
|
|
set(LLAMA_CUDA_KQUANTS_ITER "2" CACHE STRING "llama: iters./thread per block for Q2_K/Q6_K")
|
|
option(LLAMA_CLBLAST "llama: use CLBlast" OFF)
|
|
option(LLAMA_METAL "llama: use Metal" OFF)
|
|
option(LLAMA_K_QUANTS "llama: use k-quants" ON)
|
|
option(LLAMA_QKK_64 "llama: use super-block size of 64 for k-quants" OFF)
|
|
|
|
option(LLAMA_BUILD_TESTS "llama: build tests" ${LLAMA_STANDALONE})
|
|
option(LLAMA_BUILD_EXAMPLES "llama: build examples" ${LLAMA_STANDALONE})
|
|
option(LLAMA_BUILD_SERVER "llama: build server example" OFF)
|
|
|
|
#
|
|
# Build info header
|
|
#
|
|
|
|
# Generate initial build-info.h
|
|
include(${CMAKE_CURRENT_SOURCE_DIR}/scripts/build-info.cmake)
|
|
|
|
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git")
|
|
set(GIT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/.git")
|
|
|
|
# Is git submodule
|
|
if(NOT IS_DIRECTORY "${GIT_DIR}")
|
|
file(READ ${GIT_DIR} REAL_GIT_DIR_LINK)
|
|
string(REGEX REPLACE "gitdir: (.*)\n$" "\\1" REAL_GIT_DIR ${REAL_GIT_DIR_LINK})
|
|
set(GIT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/${REAL_GIT_DIR}")
|
|
endif()
|
|
|
|
# Add a custom target for build-info.h
|
|
add_custom_target(BUILD_INFO ALL DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/build-info.h")
|
|
|
|
# Add a custom command to rebuild build-info.h when .git/index changes
|
|
add_custom_command(
|
|
OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/build-info.h"
|
|
COMMENT "Generating build details from Git"
|
|
COMMAND ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_SOURCE_DIR}/scripts/build-info.cmake"
|
|
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
|
|
DEPENDS "${GIT_DIR}/index"
|
|
VERBATIM
|
|
)
|
|
else()
|
|
message(WARNING "Git repository not found; to enable automatic generation of build info, make sure Git is installed and the project is a Git repository.")
|
|
endif()
|
|
|
|
#
|
|
# Compile flags
|
|
#
|
|
|
|
set(CMAKE_CXX_STANDARD 11)
|
|
set(CMAKE_CXX_STANDARD_REQUIRED true)
|
|
set(CMAKE_C_STANDARD 11)
|
|
set(CMAKE_C_STANDARD_REQUIRED true)
|
|
set(THREADS_PREFER_PTHREAD_FLAG ON)
|
|
find_package(Threads REQUIRED)
|
|
|
|
if (NOT MSVC)
|
|
if (LLAMA_SANITIZE_THREAD)
|
|
add_compile_options(-fsanitize=thread)
|
|
link_libraries(-fsanitize=thread)
|
|
endif()
|
|
|
|
if (LLAMA_SANITIZE_ADDRESS)
|
|
add_compile_options(-fsanitize=address -fno-omit-frame-pointer)
|
|
link_libraries(-fsanitize=address)
|
|
endif()
|
|
|
|
if (LLAMA_SANITIZE_UNDEFINED)
|
|
add_compile_options(-fsanitize=undefined)
|
|
link_libraries(-fsanitize=undefined)
|
|
endif()
|
|
endif()
|
|
|
|
if (APPLE AND LLAMA_ACCELERATE)
|
|
find_library(ACCELERATE_FRAMEWORK Accelerate)
|
|
if (ACCELERATE_FRAMEWORK)
|
|
message(STATUS "Accelerate framework found")
|
|
|
|
add_compile_definitions(GGML_USE_ACCELERATE)
|
|
set(LLAMA_EXTRA_LIBS ${LLAMA_EXTRA_LIBS} ${ACCELERATE_FRAMEWORK})
|
|
else()
|
|
message(WARNING "Accelerate framework not found")
|
|
endif()
|
|
endif()
|
|
|
|
if (LLAMA_BLAS)
|
|
if (LLAMA_STATIC)
|
|
set(BLA_STATIC ON)
|
|
endif()
|
|
if ($(CMAKE_VERSION) VERSION_GREATER_EQUAL 3.22)
|
|
set(BLA_SIZEOF_INTEGER 8)
|
|
endif()
|
|
|
|
set(BLA_VENDOR ${LLAMA_BLAS_VENDOR})
|
|
find_package(BLAS)
|
|
|
|
if (BLAS_FOUND)
|
|
message(STATUS "BLAS found, Libraries: ${BLAS_LIBRARIES}")
|
|
|
|
if ("${BLAS_INCLUDE_DIRS}" STREQUAL "")
|
|
# BLAS_INCLUDE_DIRS is missing in FindBLAS.cmake.
|
|
# see https://gitlab.kitware.com/cmake/cmake/-/issues/20268
|
|
find_package(PkgConfig REQUIRED)
|
|
if (${LLAMA_BLAS_VENDOR} MATCHES "Generic")
|
|
pkg_check_modules(DepBLAS REQUIRED blas)
|
|
elseif (${LLAMA_BLAS_VENDOR} MATCHES "OpenBLAS")
|
|
pkg_check_modules(DepBLAS REQUIRED openblas)
|
|
elseif (${LLAMA_BLAS_VENDOR} MATCHES "FLAME")
|
|
pkg_check_modules(DepBLAS REQUIRED blis)
|
|
elseif (${LLAMA_BLAS_VENDOR} MATCHES "ATLAS")
|
|
pkg_check_modules(DepBLAS REQUIRED blas-atlas)
|
|
elseif (${LLAMA_BLAS_VENDOR} MATCHES "FlexiBLAS")
|
|
pkg_check_modules(DepBLAS REQUIRED flexiblas_api)
|
|
elseif (${LLAMA_BLAS_VENDOR} MATCHES "Intel")
|
|
# all Intel* libraries share the same include path
|
|
pkg_check_modules(DepBLAS REQUIRED mkl-sdl)
|
|
elseif (${LLAMA_BLAS_VENDOR} MATCHES "NVHPC")
|
|
# this doesn't provide pkg-config
|
|
# suggest to assign BLAS_INCLUDE_DIRS on your own
|
|
if ("${NVHPC_VERSION}" STREQUAL "")
|
|
message(WARNING "Better to set NVHPC_VERSION")
|
|
else()
|
|
set(DepBLAS_FOUND ON)
|
|
set(DepBLAS_INCLUDE_DIRS "/opt/nvidia/hpc_sdk/${CMAKE_SYSTEM_NAME}_${CMAKE_SYSTEM_PROCESSOR}/${NVHPC_VERSION}/math_libs/include")
|
|
endif()
|
|
endif()
|
|
if (DepBLAS_FOUND)
|
|
set(BLAS_INCLUDE_DIRS ${DepBLAS_INCLUDE_DIRS})
|
|
else()
|
|
message(WARNING "BLAS_INCLUDE_DIRS neither been provided nor been automatically"
|
|
" detected by pkgconfig, trying to find cblas.h from possible paths...")
|
|
find_path(BLAS_INCLUDE_DIRS
|
|
NAMES cblas.h
|
|
HINTS
|
|
/usr/include
|
|
/usr/local/include
|
|
/usr/include/openblas
|
|
/opt/homebrew/opt/openblas/include
|
|
/usr/local/opt/openblas/include
|
|
/usr/include/x86_64-linux-gnu/openblas/include
|
|
)
|
|
endif()
|
|
endif()
|
|
|
|
message(STATUS "BLAS found, Includes: ${BLAS_INCLUDE_DIRS}")
|
|
add_compile_options(${BLAS_LINKER_FLAGS})
|
|
add_compile_definitions(GGML_USE_OPENBLAS)
|
|
set(LLAMA_EXTRA_LIBS ${LLAMA_EXTRA_LIBS} ${BLAS_LIBRARIES})
|
|
set(LLAMA_EXTRA_INCLUDES ${LLAMA_EXTRA_INCLUDES} ${BLAS_INCLUDE_DIRS})
|
|
|
|
else()
|
|
message(WARNING "BLAS not found, please refer to "
|
|
"https://cmake.org/cmake/help/latest/module/FindBLAS.html#blas-lapack-vendors"
|
|
" to set correct LLAMA_BLAS_VENDOR")
|
|
endif()
|
|
endif()
|
|
|
|
if (LLAMA_K_QUANTS)
|
|
set(GGML_SOURCES_EXTRA ${GGML_SOURCES_EXTRA} k_quants.c k_quants.h)
|
|
add_compile_definitions(GGML_USE_K_QUANTS)
|
|
if (LLAMA_QKK_64)
|
|
add_compile_definitions(GGML_QKK_64)
|
|
endif()
|
|
endif()
|
|
|
|
if (LLAMA_CUBLAS)
|
|
cmake_minimum_required(VERSION 3.17)
|
|
|
|
find_package(CUDAToolkit)
|
|
if (CUDAToolkit_FOUND)
|
|
message(STATUS "cuBLAS found")
|
|
|
|
enable_language(CUDA)
|
|
|
|
set(GGML_SOURCES_CUDA ggml-cuda.cu ggml-cuda.h)
|
|
|
|
add_compile_definitions(GGML_USE_CUBLAS)
|
|
add_compile_definitions(GGML_CUDA_DMMV_X=${LLAMA_CUDA_DMMV_X})
|
|
add_compile_definitions(GGML_CUDA_DMMV_Y=${LLAMA_CUDA_DMMV_Y})
|
|
if (LLAMA_CUDA_DMMV_F16)
|
|
add_compile_definitions(GGML_CUDA_DMMV_F16)
|
|
endif()
|
|
add_compile_definitions(K_QUANTS_PER_ITERATION=${LLAMA_CUDA_KQUANTS_ITER})
|
|
|
|
if (LLAMA_STATIC)
|
|
set(LLAMA_EXTRA_LIBS ${LLAMA_EXTRA_LIBS} CUDA::cudart_static CUDA::cublas_static CUDA::cublasLt_static)
|
|
else()
|
|
set(LLAMA_EXTRA_LIBS ${LLAMA_EXTRA_LIBS} CUDA::cudart CUDA::cublas CUDA::cublasLt)
|
|
endif()
|
|
|
|
if (NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
|
|
if (LLAMA_CUDA_DMMV_F16)
|
|
set(CMAKE_CUDA_ARCHITECTURES "61") # needed for f16 CUDA intrinsics
|
|
else()
|
|
set(CMAKE_CUDA_ARCHITECTURES "52") # lowest CUDA 12 standard
|
|
endif()
|
|
endif()
|
|
message(STATUS "Using CUDA architectures: ${CMAKE_CUDA_ARCHITECTURES}")
|
|
|
|
else()
|
|
message(WARNING "cuBLAS not found")
|
|
endif()
|
|
endif()
|
|
|
|
if (LLAMA_METAL)
|
|
find_library(FOUNDATION_LIBRARY Foundation REQUIRED)
|
|
find_library(METAL_FRAMEWORK Metal REQUIRED)
|
|
find_library(METALKIT_FRAMEWORK MetalKit REQUIRED)
|
|
find_library(METALPERFORMANCE_FRAMEWORK MetalPerformanceShaders REQUIRED)
|
|
|
|
set(GGML_SOURCES_METAL ggml-metal.m ggml-metal.h)
|
|
|
|
add_compile_definitions(GGML_USE_METAL)
|
|
add_compile_definitions(GGML_METAL_NDEBUG)
|
|
|
|
# get full path to the file
|
|
#add_compile_definitions(GGML_METAL_DIR_KERNELS="${CMAKE_CURRENT_SOURCE_DIR}/")
|
|
|
|
# copy ggml-metal.metal to bin directory
|
|
configure_file(ggml-metal.metal bin/ggml-metal.metal COPYONLY)
|
|
|
|
set(LLAMA_EXTRA_LIBS ${LLAMA_EXTRA_LIBS}
|
|
${FOUNDATION_LIBRARY}
|
|
${METAL_FRAMEWORK}
|
|
${METALKIT_FRAMEWORK}
|
|
${METALPERFORMANCE_FRAMEWORK}
|
|
)
|
|
endif()
|
|
|
|
if (LLAMA_CLBLAST)
|
|
find_package(CLBlast)
|
|
if (CLBlast_FOUND)
|
|
message(STATUS "CLBlast found")
|
|
|
|
set(GGML_SOURCES_OPENCL ggml-opencl.cpp ggml-opencl.h)
|
|
|
|
add_compile_definitions(GGML_USE_CLBLAST)
|
|
|
|
set(LLAMA_EXTRA_LIBS ${LLAMA_EXTRA_LIBS} clblast)
|
|
else()
|
|
message(WARNING "CLBlast not found")
|
|
endif()
|
|
endif()
|
|
|
|
if (LLAMA_ALL_WARNINGS)
|
|
if (NOT MSVC)
|
|
set(c_flags
|
|
-Wall
|
|
-Wextra
|
|
-Wpedantic
|
|
-Wcast-qual
|
|
-Wdouble-promotion
|
|
-Wshadow
|
|
-Wstrict-prototypes
|
|
-Wpointer-arith
|
|
)
|
|
set(cxx_flags
|
|
-Wall
|
|
-Wextra
|
|
-Wpedantic
|
|
-Wcast-qual
|
|
-Wno-unused-function
|
|
-Wno-multichar
|
|
)
|
|
else()
|
|
# todo : msvc
|
|
endif()
|
|
|
|
add_compile_options(
|
|
"$<$<COMPILE_LANGUAGE:C>:${c_flags}>"
|
|
"$<$<COMPILE_LANGUAGE:CXX>:${cxx_flags}>"
|
|
)
|
|
|
|
endif()
|
|
|
|
if (MSVC)
|
|
add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
|
|
|
|
if (BUILD_SHARED_LIBS)
|
|
set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
|
|
endif()
|
|
endif()
|
|
|
|
if (LLAMA_LTO)
|
|
include(CheckIPOSupported)
|
|
check_ipo_supported(RESULT result OUTPUT output)
|
|
if (result)
|
|
set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
|
|
else()
|
|
message(WARNING "IPO is not supported: ${output}")
|
|
endif()
|
|
endif()
|
|
|
|
# Architecture specific
|
|
# TODO: probably these flags need to be tweaked on some architectures
|
|
# feel free to update the Makefile for your architecture and send a pull request or issue
|
|
message(STATUS "CMAKE_SYSTEM_PROCESSOR: ${CMAKE_SYSTEM_PROCESSOR}")
|
|
if (NOT MSVC)
|
|
if (LLAMA_STATIC)
|
|
add_link_options(-static)
|
|
if (MINGW)
|
|
add_link_options(-static-libgcc -static-libstdc++)
|
|
endif()
|
|
endif()
|
|
if (LLAMA_GPROF)
|
|
add_compile_options(-pg)
|
|
endif()
|
|
if (LLAMA_NATIVE)
|
|
add_compile_options(-march=native)
|
|
endif()
|
|
endif()
|
|
|
|
if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm" OR ${CMAKE_SYSTEM_PROCESSOR} MATCHES "aarch64")
|
|
message(STATUS "ARM detected")
|
|
if (MSVC)
|
|
# TODO: arm msvc?
|
|
else()
|
|
if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "armv6")
|
|
# Raspberry Pi 1, Zero
|
|
add_compile_options(-mfpu=neon-fp-armv8 -mfp16-format=ieee -mno-unaligned-access)
|
|
endif()
|
|
if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "armv7")
|
|
# Raspberry Pi 2
|
|
add_compile_options(-mfpu=neon-fp-armv8 -mfp16-format=ieee -mno-unaligned-access -funsafe-math-optimizations)
|
|
endif()
|
|
if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "armv8")
|
|
# Raspberry Pi 3, 4, Zero 2 (32-bit)
|
|
add_compile_options(-mfp16-format=ieee -mno-unaligned-access)
|
|
endif()
|
|
endif()
|
|
elseif (${CMAKE_SYSTEM_PROCESSOR} MATCHES "^(x86_64|i686|AMD64)$")
|
|
message(STATUS "x86 detected")
|
|
if (MSVC)
|
|
if (LLAMA_AVX512)
|
|
add_compile_options($<$<COMPILE_LANGUAGE:C>:/arch:AVX512>)
|
|
add_compile_options($<$<COMPILE_LANGUAGE:CXX>:/arch:AVX512>)
|
|
# MSVC has no compile-time flags enabling specific
|
|
# AVX512 extensions, neither it defines the
|
|
# macros corresponding to the extensions.
|
|
# Do it manually.
|
|
if (LLAMA_AVX512_VBMI)
|
|
add_compile_definitions($<$<COMPILE_LANGUAGE:C>:__AVX512VBMI__>)
|
|
add_compile_definitions($<$<COMPILE_LANGUAGE:CXX>:__AVX512VBMI__>)
|
|
endif()
|
|
if (LLAMA_AVX512_VNNI)
|
|
add_compile_definitions($<$<COMPILE_LANGUAGE:C>:__AVX512VNNI__>)
|
|
add_compile_definitions($<$<COMPILE_LANGUAGE:CXX>:__AVX512VNNI__>)
|
|
endif()
|
|
elseif (LLAMA_AVX2)
|
|
add_compile_options($<$<COMPILE_LANGUAGE:C>:/arch:AVX2>)
|
|
add_compile_options($<$<COMPILE_LANGUAGE:CXX>:/arch:AVX2>)
|
|
elseif (LLAMA_AVX)
|
|
add_compile_options($<$<COMPILE_LANGUAGE:C>:/arch:AVX>)
|
|
add_compile_options($<$<COMPILE_LANGUAGE:CXX>:/arch:AVX>)
|
|
endif()
|
|
else()
|
|
if (LLAMA_F16C)
|
|
add_compile_options(-mf16c)
|
|
endif()
|
|
if (LLAMA_FMA)
|
|
add_compile_options(-mfma)
|
|
endif()
|
|
if (LLAMA_AVX)
|
|
add_compile_options(-mavx)
|
|
endif()
|
|
if (LLAMA_AVX2)
|
|
add_compile_options(-mavx2)
|
|
endif()
|
|
if (LLAMA_AVX512)
|
|
add_compile_options(-mavx512f)
|
|
add_compile_options(-mavx512bw)
|
|
endif()
|
|
if (LLAMA_AVX512_VBMI)
|
|
add_compile_options(-mavx512vbmi)
|
|
endif()
|
|
if (LLAMA_AVX512_VNNI)
|
|
add_compile_options(-mavx512vnni)
|
|
endif()
|
|
endif()
|
|
elseif (${CMAKE_SYSTEM_PROCESSOR} MATCHES "ppc64")
|
|
message(STATUS "PowerPC detected")
|
|
add_compile_options(-mcpu=native -mtune=native)
|
|
#TODO: Add targets for Power8/Power9 (Altivec/VSX) and Power10(MMA) and query for big endian systems (ppc64/le/be)
|
|
else()
|
|
message(STATUS "Unknown architecture")
|
|
endif()
|
|
|
|
#
|
|
# Build libraries
|
|
#
|
|
|
|
add_library(ggml OBJECT
|
|
ggml.c
|
|
ggml.h
|
|
${GGML_SOURCES_CUDA}
|
|
${GGML_SOURCES_OPENCL}
|
|
${GGML_SOURCES_METAL}
|
|
${GGML_SOURCES_EXTRA}
|
|
)
|
|
|
|
target_include_directories(ggml PUBLIC . ${LLAMA_EXTRA_INCLUDES})
|
|
target_compile_features(ggml PUBLIC c_std_11) # don't bump
|
|
target_link_libraries(ggml PUBLIC Threads::Threads ${LLAMA_EXTRA_LIBS})
|
|
|
|
add_library(ggml_static STATIC $<TARGET_OBJECTS:ggml>)
|
|
if (BUILD_SHARED_LIBS)
|
|
set_target_properties(ggml PROPERTIES POSITION_INDEPENDENT_CODE ON)
|
|
add_library(ggml_shared SHARED $<TARGET_OBJECTS:ggml>)
|
|
target_link_libraries(ggml_shared PUBLIC Threads::Threads ${LLAMA_EXTRA_LIBS})
|
|
endif()
|
|
|
|
add_library(llama
|
|
llama.cpp
|
|
llama.h
|
|
llama-util.h
|
|
)
|
|
|
|
target_include_directories(llama PUBLIC .)
|
|
target_compile_features(llama PUBLIC cxx_std_11) # don't bump
|
|
target_link_libraries(llama PRIVATE
|
|
ggml
|
|
${LLAMA_EXTRA_LIBS}
|
|
)
|
|
|
|
if (BUILD_SHARED_LIBS)
|
|
set_target_properties(llama PROPERTIES POSITION_INDEPENDENT_CODE ON)
|
|
target_compile_definitions(llama PRIVATE LLAMA_SHARED LLAMA_BUILD)
|
|
if (LLAMA_METAL)
|
|
set_target_properties(llama PROPERTIES RESOURCE "${CMAKE_CURRENT_SOURCE_DIR}/ggml-metal.metal")
|
|
endif()
|
|
endif()
|
|
|
|
|
|
#
|
|
# programs, examples and tests
|
|
#
|
|
|
|
if (LLAMA_BUILD_TESTS AND NOT CMAKE_JS_VERSION)
|
|
include(CTest)
|
|
add_subdirectory(tests)
|
|
endif ()
|
|
|
|
if (LLAMA_BUILD_EXAMPLES)
|
|
add_subdirectory(examples)
|
|
add_subdirectory(pocs)
|
|
endif()
|