Adding missing features of CMakeLists.txt & Refactoring (#131)

* Functionality addition CMakeLists.txt

Refactoring:
1. Simplify more options that are negation of negation.
LLAMA_NO_ACCELERATE -> LLAMA_ACCELERATE
2. Changed to an optional expression instead of forcing to enable AVX2 in MSVC.
3. Make CMAKE_CXX_STANDARD, which is different from Makefile, the same.
4. Use add_compile_options instead of adding options to CMAKE_C_FLAGS.
5. Make utils use target_link_libraries instead of directly referencing code.

Added features:
1. Added some options.
LLAMA_STATIC_LINK,LLAMA_NATIVE,LLAMA_LTO,LLAMA_GPROF,LLAMA_OPENBLAS

* Fix Accelerate link in CMake

* Windows build Fix

* C++11 to C++17

* Reflects C/C++ standard individually

* Change the version to 3.12

---------

Co-authored-by: Georgi Gerganov <ggerganov@gmail.com>

CMakeLists.txt

@@ -1,131 +1,208 @@
-cmake_minimum_required(VERSION 3.8)
+cmake_minimum_required(VERSION 3.12)
-project("llama.cpp")
+project("llama.cpp" C CXX)
-
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED true)
-set(CMAKE_C_STANDARD 11)
-set(THREADS_PREFER_PTHREAD_FLAG ON)
-find_package(Threads REQUIRED)
 
 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()
 
+#
+# 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)
 
-if (APPLE)
+# instruction set specific
-    option(LLAMA_NO_ACCELERATE       "llama: disable Accelerate framework" OFF)
+option(LLAMA_AVX                    "llama: enable AVX"                                     ON)
-    option(LLAMA_NO_AVX              "llama: disable AVX" OFF)
+option(LLAMA_AVX2                   "llama: enable AVX2"                                    ON)
-    option(LLAMA_NO_AVX2             "llama: disable AVX2" OFF)
+option(LLAMA_FMA                    "llama: enable FMA"                                     ON)
-    option(LLAMA_NO_FMA              "llama: disable FMA" OFF)
+
-endif()
+# 3rd party libs
+option(LLAMA_ACCELERATE             "llama: enable Accelerate framework"                    ON)
+option(LLAMA_OPENBLAS               "llama: use OpenBLAS"                                   OFF)
+
+#
+# Compile flags
+#
+
+set(CMAKE_CXX_STANDARD_REQUIRED true)
+set(CMAKE_C_STANDARD_REQUIRED true)
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
 
 if (NOT MSVC)
     if (LLAMA_SANITIZE_THREAD)
-        set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   -fsanitize=thread")
+        add_compile_options(-fsanitize=thread)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread")
     endif()
 
     if (LLAMA_SANITIZE_ADDRESS)
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}     -fsanitize=address -fno-omit-frame-pointer")
+        add_compile_options(-fsanitize=address -fno-omit-frame-pointer)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
     endif()
 
     if (LLAMA_SANITIZE_UNDEFINED)
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}     -fsanitize=undefined")
+        add_compile_options(-fsanitize=undefined)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=undefined")
     endif()
 endif()
 
-if (APPLE AND NOT LLAMA_NO_ACCELERATE)
+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})
-        set(LLAMA_EXTRA_FLAGS ${LLAMA_EXTRA_FLAGS} -DGGML_USE_ACCELERATE)
     else()
         message(WARNING "Accelerate framework not found")
     endif()
 endif()
+if (LLAMA_OPENBLAS)
+    if (LLAMA_STATIC)
+        set(BLA_STATIC ON)
+    endif()
+
+    set(BLA_VENDOR OpenBLAS)
+    find_package(BLAS)
+    if (BLAS_FOUND)
+        message(STATUS "OpenBLAS found")
+
+        add_compile_definitions(GGML_USE_OPENBLAS)
+        add_link_options(${BLAS_LIBRARIES})
+    else()
+        message(WARNING "OpenBLAS not found")
+    endif()
+endif()
 
 if (LLAMA_ALL_WARNINGS)
     if (NOT MSVC)
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} \
+        set(c_flags
-            -Wall                           \
+            -Wall
-            -Wextra                         \
+            -Wextra
-            -Wpedantic                      \
+            -Wpedantic
-            -Wshadow                        \
+            -Wshadow
-            -Wcast-qual                     \
+            -Wcast-qual
-            -Wstrict-prototypes             \
+            -Wstrict-prototypes
-            -Wpointer-arith                 \
+            -Wpointer-arith
-            -Wno-unused-function            \
+            -Wno-unused-function
-        ")
+        )
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} \
+        set(cxx_flags
-            -Wall                           \
+            -Wall
-            -Wextra                         \
+            -Wextra
-            -Wpedantic                      \
+            -Wpedantic
-            -Wcast-qual                     \
+            -Wcast-qual
-        ")
+        )
     else()
         # todo : msvc
     endif()
+
+    add_compile_options(
+            "$<$<COMPILE_LANGUAGE:C>:${c_flags}>"
+            "$<$<COMPILE_LANGUAGE:CXX>:${cxx_flags}>"
+    )
+
 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 "aarch64")
+            add_compile_options(-mcpu=native)
+        endif()
+        # TODO: armv6,7,8 version specific flags
+    endif()
+elseif (${CMAKE_SYSTEM_PROCESSOR} MATCHES "^(x86_64|i686|AMD64)$")
     message(STATUS "x86 detected")
     if (MSVC)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:AVX2")
+        if (LLAMA_AVX2)
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /arch:AVX2")
+            add_compile_options(/arch:AVX2)
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /arch:AVX2")
+        elseif (LLAMA_AVX)
+            add_compile_options(/arch:AVX)
+        endif()
     else()
-        if(NOT LLAMA_NO_AVX)
+        add_compile_options(-mf16c)
-            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mavx")
+        if (LLAMA_FMA)
+            add_compile_options(-mfma)
         endif()
-        if(NOT LLAMA_NO_AVX2)
+        if (LLAMA_AVX)
-            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mavx2")
+            add_compile_options(-mavx)
         endif()
-        if(NOT LLAMA_NO_FMA)
+        if (LLAMA_AVX2)
-            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfma")
+            add_compile_options(-mavx2)
         endif()
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mf16c")
     endif()
+else()
+    # TODO: support PowerPC
+    message(STATUS "Unknown architecture")
 endif()
 
-# if (LLAMA_PERF)
-#     set(LLAMA_EXTRA_FLAGS ${LLAMA_EXTRA_FLAGS} -DGGML_PERF)
-# endif()
 
-add_executable(llama
+#
-    main.cpp
+# Build library
-    utils.cpp
+#
-    utils.h)
 
-add_executable(quantize
+add_executable(llama main.cpp)
-    quantize.cpp
-    utils.cpp
-    utils.h)
 
-add_library(ggml
+add_executable(quantize quantize.cpp)
+
+add_library(ggml OBJECT
             ggml.c
             ggml.h)
 
-target_compile_definitions(ggml PUBLIC ${LLAMA_EXTRA_FLAGS})
+add_library(utils OBJECT
-target_compile_definitions(llama PUBLIC ${LLAMA_EXTRA_FLAGS})
+            utils.cpp
-target_compile_definitions(quantize PUBLIC ${LLAMA_EXTRA_FLAGS})
+            utils.h)
 
-target_link_libraries(ggml PRIVATE ${LLAMA_EXTRA_LIBS})
 target_include_directories(ggml PUBLIC .)
-target_link_libraries(quantize PRIVATE ggml)
+target_compile_features(ggml PUBLIC c_std_11)
-target_link_libraries(llama PRIVATE ggml)
+target_compile_features(utils PUBLIC cxx_std_17)
-target_link_libraries(ggml PRIVATE Threads::Threads)
+
+#
+# Linking
+#
+
+target_link_libraries(ggml PRIVATE Threads::Threads ${LLAMA_EXTRA_LIBS})
+target_link_libraries(llama PRIVATE ggml utils)
+target_link_libraries(quantize PRIVATE ggml utils)