mirror of
https://github.com/ggerganov/llama.cpp.git
synced 2024-12-28 15:18:26 +01:00
19d8762ab6
* rename ggml-cpu-aarch64.c to .cpp
* reformat extra cpu backend.
- clean Q4_0_N_M and IQ4_0_N_M
- remove from "file" tensor type
- allow only with dynamic repack
- extract cpu extra bufts and convert to C++
- hbm
- "aarch64"
- more generic use of extra buffer
- generalise extra_supports_op
- new API for "cpu-accel":
- amx
- aarch64
* clang-format
* Clean Q4_0_N_M ref
Enable restrict on C++
* add op GGML_OP_MUL_MAT_ID for Q4_0_N_M with runtime repack
* added/corrected control on tensor size for Q4 repacking.
* Update ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp
Co-authored-by: Georgi Gerganov <ggerganov@gmail.com>
* Update ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp
Co-authored-by: Georgi Gerganov <ggerganov@gmail.com>
* add debug logs on repacks.
---------
Co-authored-by: Georgi Gerganov <ggerganov@gmail.com>
342 lines
11 KiB
CMake
342 lines
11 KiB
CMake
include(CheckCXXCompilerFlag)
|
|
|
|
add_compile_definitions(GGML_SCHED_MAX_COPIES=${GGML_SCHED_MAX_COPIES})
|
|
|
|
# enable libstdc++ assertions for debug builds
|
|
if (CMAKE_SYSTEM_NAME MATCHES "Linux")
|
|
add_compile_definitions($<$<CONFIG:Debug>:_GLIBCXX_ASSERTIONS>)
|
|
endif()
|
|
|
|
if (NOT MSVC)
|
|
if (GGML_SANITIZE_THREAD)
|
|
add_compile_options(-fsanitize=thread)
|
|
link_libraries (-fsanitize=thread)
|
|
endif()
|
|
|
|
if (GGML_SANITIZE_ADDRESS)
|
|
add_compile_options(-fsanitize=address -fno-omit-frame-pointer)
|
|
link_libraries (-fsanitize=address)
|
|
endif()
|
|
|
|
if (GGML_SANITIZE_UNDEFINED)
|
|
add_compile_options(-fsanitize=undefined)
|
|
link_libraries (-fsanitize=undefined)
|
|
endif()
|
|
endif()
|
|
|
|
function(ggml_get_flags CCID CCVER)
|
|
set(C_FLAGS "")
|
|
set(CXX_FLAGS "")
|
|
|
|
if (CCID MATCHES "Clang")
|
|
set(C_FLAGS -Wunreachable-code-break -Wunreachable-code-return)
|
|
set(CXX_FLAGS -Wunreachable-code-break -Wunreachable-code-return -Wmissing-prototypes -Wextra-semi)
|
|
|
|
if (
|
|
(CCID STREQUAL "Clang" AND CCVER VERSION_GREATER_EQUAL 3.8.0) OR
|
|
(CCID STREQUAL "AppleClang" AND CCVER VERSION_GREATER_EQUAL 7.3.0)
|
|
)
|
|
list(APPEND C_FLAGS -Wdouble-promotion)
|
|
endif()
|
|
elseif (CCID STREQUAL "GNU")
|
|
set(C_FLAGS -Wdouble-promotion)
|
|
set(CXX_FLAGS -Wno-array-bounds)
|
|
|
|
if (CCVER VERSION_GREATER_EQUAL 8.1.0)
|
|
list(APPEND CXX_FLAGS -Wextra-semi)
|
|
endif()
|
|
endif()
|
|
|
|
set(GF_C_FLAGS ${C_FLAGS} PARENT_SCOPE)
|
|
set(GF_CXX_FLAGS ${CXX_FLAGS} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
if (GGML_FATAL_WARNINGS)
|
|
if (CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
|
|
list(APPEND C_FLAGS -Werror)
|
|
list(APPEND CXX_FLAGS -Werror)
|
|
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
|
|
add_compile_options(/WX)
|
|
endif()
|
|
endif()
|
|
|
|
if (GGML_ALL_WARNINGS)
|
|
if (NOT MSVC)
|
|
list(APPEND WARNING_FLAGS -Wall -Wextra -Wpedantic -Wcast-qual -Wno-unused-function)
|
|
list(APPEND C_FLAGS -Wshadow -Wstrict-prototypes -Wpointer-arith -Wmissing-prototypes
|
|
-Werror=implicit-int -Werror=implicit-function-declaration)
|
|
list(APPEND CXX_FLAGS -Wmissing-declarations -Wmissing-noreturn)
|
|
|
|
list(APPEND C_FLAGS ${WARNING_FLAGS})
|
|
list(APPEND CXX_FLAGS ${WARNING_FLAGS})
|
|
|
|
ggml_get_flags(${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION})
|
|
|
|
add_compile_options("$<$<COMPILE_LANGUAGE:C>:${C_FLAGS};${GF_C_FLAGS}>"
|
|
"$<$<COMPILE_LANGUAGE:CXX>:${CXX_FLAGS};${GF_CXX_FLAGS}>")
|
|
else()
|
|
# todo : msvc
|
|
set(C_FLAGS "")
|
|
set(CXX_FLAGS "")
|
|
endif()
|
|
endif()
|
|
|
|
if (GGML_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()
|
|
|
|
if (GGML_CCACHE)
|
|
find_program(GGML_CCACHE_FOUND ccache)
|
|
|
|
if (GGML_CCACHE_FOUND)
|
|
# TODO: should not be set globally
|
|
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
|
|
set(ENV{CCACHE_SLOPPINESS} time_macros)
|
|
message(STATUS "ccache found, compilation results will be cached. Disable with GGML_CCACHE=OFF.")
|
|
else()
|
|
message(STATUS "Warning: ccache not found - consider installing it for faster compilation or disable this warning with GGML_CCACHE=OFF")
|
|
endif ()
|
|
endif()
|
|
|
|
# this version of Apple ld64 is buggy
|
|
execute_process(
|
|
COMMAND ${CMAKE_C_COMPILER} ${CMAKE_EXE_LINKER_FLAGS} -Wl,-v
|
|
ERROR_VARIABLE output
|
|
OUTPUT_QUIET
|
|
)
|
|
|
|
if (output MATCHES "dyld-1015\.7")
|
|
add_compile_definitions(HAVE_BUGGY_APPLE_LINKER)
|
|
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 (MSVC)
|
|
string(TOLOWER "${CMAKE_GENERATOR_PLATFORM}" CMAKE_GENERATOR_PLATFORM_LWR)
|
|
message(STATUS "CMAKE_GENERATOR_PLATFORM: ${CMAKE_GENERATOR_PLATFORM}")
|
|
else ()
|
|
set(CMAKE_GENERATOR_PLATFORM_LWR "")
|
|
endif ()
|
|
|
|
if (NOT MSVC)
|
|
if (GGML_STATIC)
|
|
add_link_options(-static)
|
|
if (MINGW)
|
|
add_link_options(-static-libgcc -static-libstdc++)
|
|
endif()
|
|
endif()
|
|
if (GGML_GPROF)
|
|
add_compile_options(-pg)
|
|
endif()
|
|
endif()
|
|
|
|
if (MINGW)
|
|
# Target Windows 8 for PrefetchVirtualMemory
|
|
add_compile_definitions(_WIN32_WINNT=${GGML_WIN_VER})
|
|
endif()
|
|
|
|
#
|
|
# POSIX conformance
|
|
#
|
|
|
|
# clock_gettime came in POSIX.1b (1993)
|
|
# CLOCK_MONOTONIC came in POSIX.1-2001 / SUSv3 as optional
|
|
# posix_memalign came in POSIX.1-2001 / SUSv3
|
|
# M_PI is an XSI extension since POSIX.1-2001 / SUSv3, came in XPG1 (1985)
|
|
|
|
# Somehow in OpenBSD whenever POSIX conformance is specified
|
|
# some string functions rely on locale_t availability,
|
|
# which was introduced in POSIX.1-2008, forcing us to go higher
|
|
if (CMAKE_SYSTEM_NAME MATCHES "OpenBSD")
|
|
add_compile_definitions(_XOPEN_SOURCE=700)
|
|
else()
|
|
add_compile_definitions(_XOPEN_SOURCE=600)
|
|
endif()
|
|
|
|
# Data types, macros and functions related to controlling CPU affinity and
|
|
# some memory allocation are available on Linux through GNU extensions in libc
|
|
if (CMAKE_SYSTEM_NAME MATCHES "Linux" OR CMAKE_SYSTEM_NAME MATCHES "Android")
|
|
add_compile_definitions(_GNU_SOURCE)
|
|
endif()
|
|
|
|
# RLIMIT_MEMLOCK came in BSD, is not specified in POSIX.1,
|
|
# and on macOS its availability depends on enabling Darwin extensions
|
|
# similarly on DragonFly, enabling BSD extensions is necessary
|
|
if (
|
|
CMAKE_SYSTEM_NAME MATCHES "Darwin" OR
|
|
CMAKE_SYSTEM_NAME MATCHES "iOS" OR
|
|
CMAKE_SYSTEM_NAME MATCHES "tvOS" OR
|
|
CMAKE_SYSTEM_NAME MATCHES "DragonFly"
|
|
)
|
|
add_compile_definitions(_DARWIN_C_SOURCE)
|
|
endif()
|
|
|
|
# alloca is a non-standard interface that is not visible on BSDs when
|
|
# POSIX conformance is specified, but not all of them provide a clean way
|
|
# to enable it in such cases
|
|
if (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
|
|
add_compile_definitions(__BSD_VISIBLE)
|
|
endif()
|
|
if (CMAKE_SYSTEM_NAME MATCHES "NetBSD")
|
|
add_compile_definitions(_NETBSD_SOURCE)
|
|
endif()
|
|
if (CMAKE_SYSTEM_NAME MATCHES "OpenBSD")
|
|
add_compile_definitions(_BSD_SOURCE)
|
|
endif()
|
|
|
|
if (WIN32)
|
|
add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
|
|
|
|
if (BUILD_SHARED_LIBS)
|
|
# TODO: should not use this
|
|
set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
|
|
endif()
|
|
endif()
|
|
|
|
# ggml
|
|
|
|
if (GGML_BACKEND_DL AND NOT BUILD_SHARED_LIBS)
|
|
message(FATAL_ERROR "GGML_BACKEND_DL requires BUILD_SHARED_LIBS")
|
|
endif()
|
|
|
|
add_library(ggml-base
|
|
../include/ggml.h
|
|
../include/ggml-alloc.h
|
|
../include/ggml-backend.h
|
|
../include/ggml-cpp.h
|
|
../include/ggml-opt.h
|
|
ggml.c
|
|
ggml-alloc.c
|
|
ggml-backend.cpp
|
|
ggml-opt.cpp
|
|
ggml-threading.cpp
|
|
ggml-threading.h
|
|
ggml-quants.c
|
|
ggml-quants.h)
|
|
|
|
target_include_directories(ggml-base PRIVATE .)
|
|
|
|
add_library(ggml
|
|
ggml-backend-reg.cpp)
|
|
|
|
target_link_libraries(ggml PUBLIC ggml-base)
|
|
|
|
if (CMAKE_SYSTEM_NAME MATCHES "Linux")
|
|
target_link_libraries(ggml PRIVATE dl)
|
|
endif()
|
|
|
|
function(ggml_add_backend_library backend)
|
|
if (GGML_BACKEND_DL)
|
|
add_library(${backend} MODULE ${ARGN})
|
|
# write the shared library to the output directory
|
|
set_target_properties(${backend} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
|
|
target_compile_definitions(${backend} PRIVATE GGML_BACKEND_DL)
|
|
else()
|
|
add_library(${backend} ${ARGN})
|
|
target_link_libraries(ggml PUBLIC ${backend})
|
|
install(TARGETS ${backend} LIBRARY)
|
|
endif()
|
|
|
|
target_link_libraries(${backend} PRIVATE ggml-base)
|
|
target_include_directories(${backend} PRIVATE ..)
|
|
|
|
if (${BUILD_SHARED_LIBS})
|
|
target_compile_definitions(${backend} PRIVATE GGML_BACKEND_BUILD)
|
|
target_compile_definitions(${backend} PUBLIC GGML_BACKEND_SHARED)
|
|
endif()
|
|
endfunction()
|
|
|
|
function(ggml_add_backend backend)
|
|
string(TOUPPER "GGML_${backend}" backend_id)
|
|
if (${backend_id})
|
|
string(TOLOWER "ggml-${backend}" backend_target)
|
|
add_subdirectory(${backend_target})
|
|
message(STATUS "Including ${backend} backend")
|
|
if (NOT GGML_BACKEND_DL)
|
|
string(TOUPPER "GGML_USE_${backend}" backend_use)
|
|
target_compile_definitions(ggml PUBLIC ${backend_use})
|
|
endif()
|
|
endif()
|
|
endfunction()
|
|
|
|
function(ggml_add_cpu_backend_variant tag_name)
|
|
set(GGML_CPU_TAG_NAME ${tag_name})
|
|
# other: OPENMP LLAMAFILE CPU_HBM
|
|
foreach (feat NATIVE
|
|
AVX AVX2 AVX_VNNI FMA F16C
|
|
AVX512 AVX512_VBMI AVX512_VNNI AVX512_BF16
|
|
AMX_TILE AMX_INT8 AMX_BF16)
|
|
set(GGML_${feat} OFF)
|
|
endforeach()
|
|
|
|
foreach (feat ${ARGN})
|
|
set(GGML_${feat} ON)
|
|
endforeach()
|
|
|
|
ggml_add_cpu_backend_variant_impl(${tag_name})
|
|
endfunction()
|
|
|
|
ggml_add_backend(CPU)
|
|
|
|
if (GGML_CPU_ALL_VARIANTS)
|
|
if (NOT GGML_BACKEND_DL)
|
|
message(FATAL_ERROR "GGML_CPU_ALL_VARIANTS requires GGML_BACKEND_DL")
|
|
endif()
|
|
ggml_add_cpu_backend_variant(sandybridge AVX)
|
|
ggml_add_cpu_backend_variant(haswell AVX F16C AVX2 FMA)
|
|
ggml_add_cpu_backend_variant(skylakex AVX F16C AVX2 FMA AVX512)
|
|
ggml_add_cpu_backend_variant(icelake AVX F16C AVX2 FMA AVX512 AVX512_VBMI AVX512_VNNI)
|
|
if (NOT MSVC)
|
|
# MSVC doesn't support AVX-VNNI or AMX
|
|
ggml_add_cpu_backend_variant(alderlake AVX F16C AVX2 FMA AVX_VNNI)
|
|
ggml_add_cpu_backend_variant(sapphirerapids AVX F16C AVX2 FMA AVX512 AVX512_VBMI AVX512_VNNI AVX512_BF16 AMX_TILE AMX_INT8)
|
|
endif()
|
|
else ()
|
|
ggml_add_cpu_backend_variant_impl("")
|
|
endif()
|
|
|
|
ggml_add_backend(BLAS)
|
|
ggml_add_backend(CANN)
|
|
ggml_add_backend(CUDA)
|
|
ggml_add_backend(HIP)
|
|
ggml_add_backend(Kompute)
|
|
ggml_add_backend(METAL)
|
|
ggml_add_backend(MUSA)
|
|
ggml_add_backend(RPC)
|
|
ggml_add_backend(SYCL)
|
|
ggml_add_backend(Vulkan)
|
|
|
|
foreach (target ggml-base ggml)
|
|
target_include_directories(${target} PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include> $<INSTALL_INTERFACE:include>)
|
|
target_compile_features (${target} PRIVATE c_std_11 cxx_std_17) # don't bump
|
|
endforeach()
|
|
|
|
target_link_libraries(ggml-base PRIVATE Threads::Threads)
|
|
|
|
find_library(MATH_LIBRARY m)
|
|
if (MATH_LIBRARY)
|
|
if (NOT WIN32 OR NOT DEFINED ENV{ONEAPI_ROOT})
|
|
target_link_libraries(ggml-base PRIVATE m)
|
|
endif()
|
|
endif()
|
|
|
|
if (CMAKE_SYSTEM_NAME MATCHES "Android")
|
|
target_link_libraries(ggml-base PRIVATE dl)
|
|
endif()
|
|
|
|
if (BUILD_SHARED_LIBS)
|
|
foreach (target ggml-base ggml)
|
|
set_target_properties(${target} PROPERTIES POSITION_INDEPENDENT_CODE ON)
|
|
target_compile_definitions(${target} PRIVATE GGML_BUILD)
|
|
target_compile_definitions(${target} PUBLIC GGML_SHARED)
|
|
endforeach()
|
|
endif()
|