Оптимизация CMake для ускорения сборки

set(CMAKE_CXX_FLAGS_DEBUG "-Og -g -fno-inline -fno-omit-frame-pointer")

set(CMAKE_CXX_FLAGS_DEBUG "/Od /Zi /RTC1 /JMC- /Gy-")

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pipe -fno-semantic-interposition")

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-stack-check -fno-address-sanitizer-use-after-scope")

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing -fno-rtti -fno-exceptions")

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftemporary-directory=/dev/shm/temp")

function(optimize_target target)
    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
        # Создаем PCH для стандартных заголовков
        target_precompile_headers(${target} PRIVATE
            <vector>
            <string>
            <map>
            <unordered_map>
            <memory>
            <algorithm>
        )
        
        # Устанавливаем оптимизации для этого таргета
        target_compile_options(${target} PRIVATE
            -fno-semantic-interposition
            -pipe
        )
    endif()
endfunction()
 
# Использование
add_executable(myapp main.cpp)
optimize_target(myapp)

set_target_properties(myTarget PROPERTIES UNITY_BUILD ON)

set_target_properties(myTarget PROPERTIES 
    UNITY_BUILD ON
    UNITY_BUILD_BATCH_SIZE 10)

set_source_files_properties(problematic_file.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)

target_precompile_headers(myApp PRIVATE 
    <vector>
    <string>
    "common/utility.h"
)

if(MSVC)
    target_compile_options(myTarget PRIVATE /MP)
endif()

if(MSVC)
    target_compile_options(myTarget PRIVATE /Z7)
endif()

find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM)
    set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
    set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
endif()

if(UNIX)
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fuse-ld=gold")
endif()

set_target_properties(myTarget PROPERTIES 
    UNITY_BUILD ON 
    UNITY_BUILD_UNIQUE_ID "${CMAKE_CURRENT_SOURCE_DIR}")

// Плохо: подключаем все подряд
#include <vector>
#include <string>
#include <map>
#include <unordered_map>
#include <algorithm>
#include <memory>
#include "utils.h"
#include "config.h"
#include "database.h"

# Плохо: глобальные настройки компиляции
add_definitions(-DDEBUG_MODE)
include_directories(include)
link_directories(lib)
 
# Цели
add_library(lib1 ...)
add_library(lib2 ...)
add_executable(app ...)

# Хорошо: настройки привязаны к целям
add_library(lib1 ...)
target_compile_definitions(lib1 PRIVATE -DDEBUG_MODE)
target_include_directories(lib1 PUBLIC include)
 
add_library(lib2 ...)
target_link_directories(lib2 PRIVATE lib)
 
add_executable(app ...)
target_link_libraries(app PRIVATE lib1 lib2)

# Плохо: глобальные переменные
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror")
 
# Хорошо: свойства цели
target_compile_options(mytarget PRIVATE -Wall -Werror)

// widget.h
class Widget {
public:
    Widget();
    ~Widget();
    void doSomething();
    
private:
    class Impl;
    std::unique_ptr<Impl> pimpl;
};
 
// widget.cpp
class Widget::Impl {
public:
    void doSomething() { /* ... */ }
    std::vector<int> data;
    std::map<std::string, int> mappings;
};
 
Widget::Widget() : pimpl(std::make_unique<Impl>()) {}
Widget::~Widget() = default;
void Widget::doSomething() { pimpl->doSomething(); }

// IWidget.h - только интерфейс
class IWidget {
public:
    virtual ~IWidget() = default;
    virtual void doSomething() = 0;
    
    static std::unique_ptr<IWidget> create();
};
 
// Widget.cpp - реализация
class WidgetImpl : public IWidget {
public:
    void doSomething() override { /* ... */ }
};
 
std::unique_ptr<IWidget> IWidget::create() {
    return std::make_unique<WidgetImpl>();
}

// Плохо
#include "user.h"
class Order {
    User user;  // Нужен полный класс User
};
 
// Лучше
class User;  // Предварительное объявление
class Order {
    User* user;  // Достаточно неполного типа
};

// Вместо #include <vector>
namespace std {
    template<typename T, typename A>
    class vector;
}
 
class MyClass {
    std::vector<int, std::allocator<int>>* data;  // Теперь можно использовать неполный тип
};

# Плохо: неоптимальный порядок
target_link_libraries(myapp A B C)
 
# Хорошо: библиотеки указаны в порядке зависимостей
target_link_libraries(myapp C B A)

target_precompile_headers(myapp PRIVATE 
  <vector>
  <string>
  <map>
  "common/globals.h"
)

target_precompile_headers(core_lib PRIVATE core_pch.h)
target_precompile_headers(ui_lib PRIVATE ui_pch.h)

# base_pch.h включает только базовые заголовки
target_precompile_headers(base_lib PRIVATE base_pch.h)
 
# core_pch.h включает base_pch.h и добавляет специфичные для core заголовки
target_precompile_headers(core_lib PRIVATE core_pch.h)

// math.cppm
export module math;
 
export int add(int a, int b) {
    return a + b;
}
 
// main.cpp
import math;
 
int main() {
    return add(2, 2);
}

# Включаем поддержку модулей
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP 1)
 
# Определяем модуль
add_library(math_module)
target_sources(math_module
  PRIVATE
    math.cppm
)
 
# Используем модуль
add_executable(myapp main.cpp)
target_link_libraries(myapp PRIVATE math_module)

# Базовый слой с минимальными зависимостями
add_library(base_layer ...)
target_include_directories(base_layer PUBLIC include/base)
 
# Средний слой, зависящий только от базового
add_library(middle_layer ...)
target_link_libraries(middle_layer PUBLIC base_layer)
target_include_directories(middle_layer PUBLIC include/middle)
 
# Верхний слой с большинством зависимостей
add_library(top_layer ...)
target_link_libraries(top_layer PUBLIC middle_layer)
target_include_directories(top_layer PUBLIC include/top)

# Разделяем по функциональности
add_library(network STATIC network.cpp)
add_library(database STATIC database.cpp)
add_library(ui STATIC ui.cpp)
 
# Собираем вместе в финальном исполняемом файле
add_executable(app main.cpp)
target_link_libraries(app PRIVATE network database ui)

// Оригинальная заголовочная библиотека тяжелая для компиляции
// json_wrapper.h
class JsonWrapper {
public:
  static bool parse(const std::string& input, std::string& output);
  static std::string serialize(const std::string& input);
  
private:
  // Здесь скрываем всю сложность библиотеки
};
 
// json_wrapper.cpp
#include <nlohmann/json.hpp>  // Тяжелая заголовочная библиотека
 
bool JsonWrapper::parse(...) {
  // Реализация с использованием скрытой библиотеки
}

option(QUICK_DEV_MODE "Enable quick development mode" OFF)
 
function(add_project_component name)
  if(NOT QUICK_DEV_MODE OR name IN_LIST ACTIVE_COMPONENTS)
    add_subdirectory(${name})
  else()
    # Создаем фиктивную цель
    add_custom_target(${name})
  endif()
endfunction()
 
# Использование
set(ACTIVE_COMPONENTS core ui)
add_project_component(core)       # Будет собрано
add_project_component(ui)         # Будет собрано
add_project_component(network)    # Пропущено в DEV режиме
add_project_component(analytics)  # Пропущено в DEV режиме

execute_process(
  COMMAND python3 ${CMAKE_SOURCE_DIR}/scripts/analyze_includes.py
  OUTPUT_VARIABLE PCH_CONTENT
)
 
file(WRITE ${CMAKE_BINARY_DIR}/pch.h "${PCH_CONTENT}")
 
target_precompile_headers(myapp PRIVATE ${CMAKE_BINARY_DIR}/pch.h)

add_custom_target(compile_only)
 
function(add_linkable_executable name)
  # Добавляем обычный исполняемый файл
  add_executable(${name} ${ARGN})
  
  # Добавляем цель только для компиляции объектных файлов
  add_custom_target(${name}_objects
    COMMAND ${CMAKE_COMMAND} -E echo "Compiling objects for ${name}"
    DEPENDS ${name}
    COMMAND_EXPAND_LISTS
  )
  
  # Добавляем цель только для линковки
  add_custom_target(${name}_link
    COMMAND ${CMAKE_COMMAND} -E echo "Linking ${name}"
    DEPENDS ${name}
  )
  
  # Добавляем зависимость к глобальной цели
  add_dependencies(compile_only ${name}_objects)
endfunction()
 
# Использование
add_linkable_executable(myapp main.cpp utils.cpp)

function(add_smart_unity_build target)
  # Получаем все исходные файлы
  get_target_property(sources ${target} SOURCES)
  
  # Группируем файлы по директориям
  set(unity_groups)
  foreach(source ${sources})
    get_filename_component(dir ${source} DIRECTORY)
    list(APPEND unity_groups ${dir})
  endforeach()
  list(REMOVE_DUPLICATES unity_groups)
  
  # Создаем отдельный unity-файл для каждой директории
  foreach(group ${unity_groups})
    set(unity_content "#include <algorithm>\n#include <vector>\n#include <string>\n\n")
    
    foreach(source ${sources})
      get_filename_component(dir ${source} DIRECTORY)
      if(dir STREQUAL group AND source MATCHES ".*\\.cpp$")
        string(APPEND unity_content "#include \"${source}\"\n")
      endif()
    endforeach()
    
    string(MD5 group_hash "${group}")
    set(unity_file "${CMAKE_CURRENT_BINARY_DIR}/unity_${group_hash}.cpp")
    file(WRITE ${unity_file} "${unity_content}")
    
    target_sources(${target} PRIVATE ${unity_file})
  endforeach()
  
  # Исключаем оригинальные cpp-файлы
  set_target_properties(${target} PROPERTIES UNITY_BUILD_MODE BATCH)
endfunction()

cmake_minimum_required(VERSION 3.18)
project(OptimizedProject VERSION 1.0.0 LANGUAGES CXX)
 
# Находим и настраиваем ccache/sccache
find_program(CCACHE_PROGRAM ccache)
find_program(SCCACHE_PROGRAM sccache)
if(CCACHE_PROGRAM)
  set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
  message(STATUS "Using ccache: ${CCACHE_PROGRAM}")
elseif(SCCACHE_PROGRAM)
  set(CMAKE_CXX_COMPILER_LAUNCHER "${SCCACHE_PROGRAM}")
  message(STATUS "Using sccache: ${SCCACHE_PROGRAM}")
endif()
 
# Общие настройки
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
# Выбираем быстрый линкер, если доступен
if(UNIX AND NOT APPLE)
  execute_process(
    COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version
    ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
  if("${LD_VERSION}" MATCHES "GNU gold")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fuse-ld=gold")
    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fuse-ld=gold")
    message(STATUS "Using Gold linker")
  endif()
endif()
 
# Функция для оптимизации цели
function(optimize_target target)
  # Настраиваем unity build
  set_target_properties(${target} PROPERTIES UNITY_BUILD ON)
  set_target_properties(${target} PROPERTIES UNITY_BUILD_BATCH_SIZE 10)
  
  # Предкомпилированные заголовки
  target_precompile_headers(${target} PRIVATE
    <vector>
    <string>
    <map>
    <unordered_map>
    <memory>
    <algorithm>
  )
  
  # Флаги для ускорения
  if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
    target_compile_options(${target} PRIVATE
      -pipe
      -fno-semantic-interposition
      $<$<CONFIG:Debug>:-Og -g -fno-inline>
      $<$<CONFIG:RelWithDebInfo>:-O2 -g>
    )
  elseif(MSVC)
    target_compile_options(${target} PRIVATE
      /MP    # Многопроцессорная компиляция
      $<$<CONFIG:Debug>:/JMC- /Gy->
      $<$<CONFIG:RelWithDebInfo>:/O2 /Zi>
    )
  endif()
endfunction()
 
# Функция для добавления компонента проекта
function(add_project_component name)
  message(STATUS "Adding component: ${name}")
  
  # Создаем библиотеку для компонента
  add_library(${name} ${ARGN})
  
  # Настраиваем включаемые пути по-современному
  target_include_directories(${name} 
    PUBLIC include/${name}
    PRIVATE src/${name}
  )
  
  # Применяем все оптимизации
  optimize_target(${name})
endfunction()
 
# Добавляем компоненты
add_project_component(core 
  src/core/core.cpp
  src/core/utils.cpp
)
 
add_project_component(network
  src/network/client.cpp
  src/network/server.cpp
)
 
# Основное приложение
add_executable(app src/main.cpp)
target_link_libraries(app PRIVATE core network)
optimize_target(app)
 
# Вывод информации об оптимизациях
message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
message(STATUS "C++ compiler: ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}")
message(STATUS "Unity build: ON")
message(STATUS "Precompiled headers: ON")

project/
├── CMakeLists.txt
├── include/
│   ├── core/
│   │   ├── core.h
│   │   └── utils.h
│   └── network/
│       ├── client.h
│       └── server.h
└── src/
    ├── core/
    │   ├── core.cpp
    │   └── utils.cpp
    ├── network/
    │   ├── client.cpp
    │   └── server.cpp
    └── main.cpp