Scribd
Upload
86 views

Cmake Ninja

This document discusses CMake and Ninja build systems. CMake is a build system generator that supports cross-platform builds. It generates standard build files like Makefiles from CMakeLists.txt files. Ninja is a small, fast build system that focuses on speed. The document recommends using CMake to generate build files for Ninja since CMake provides flexibility and Ninja provides speed. Together, CMake and Ninja satisfy the main requirements of a build system by providing speed, flexibility, and reliability.

Uploaded by

hello
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
86 views

Cmake Ninja

This document discusses CMake and Ninja build systems. CMake is a build system generator that supports cross-platform builds. It generates standard build files like Makefiles from CMakeLists.txt files. Ninja is a small, fast build system that focuses on speed. The document recommends using CMake to generate build files for Ninja since CMake provides flexibility and Ninja provides speed. Together, CMake and Ninja satisfy the main requirements of a build system by providing speed, flexibility, and reliability.

Uploaded by

hello
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 50

CMake & Ninja

by István Papp
[email protected]
Hello & Disclaimer

 I don’t know everything (surprise!), if I stare blankly after a question,


go to https://cmake.org/

 Spoiler alert: or https://ninja-build.org/


Contents

 Introduction
 Definitions
 CMake
 Example
 CMake as a language
 Other command line tools
 Ninja
 Tying it all together
Definitions

 A practical view from my perspective, some of these are debatable


 Send me feedback, so 2.0 will be better
What is the goal of a build system?

 Get from source* to binary*

 *Source: source code, text file, assets (textures, audio)


 *Binary: executable, zip file, text file

110
</> 011
Requirements

 Speed
 Reliability
 Flexibility
Requirements - Speed

 Fast feedback
 Catch errors ASAP
 Avoid breaking stuff for others
 Conserve resources
 No effect on the compiler*
 Avoid work
 Parallel execution

*Build step: zip, upload/download, compilation


Requirements - Reliability

 Umbrella term

 Deterministic
 Stable
 No unexpected behaviour
Requirements - Flexibility

 Large variety of tasks


 Easy to modify
 Easy to read
Sources of complexity

 Source code in multiple directories


 External libraries
 Targeting different platforms
 Compilers
 Operating systems
 Hardware
 Test code
 Mixing languages
Make

 Make is very generic


 Mostly conforms to the requirements
 Designed in 1977 (40 years old!)

 We can do better now


Contents

 Introduction
 Definitions
 CMake
 Example
 CMake as a language
 Other command line tools
 Ninja
 Tying it all together
CMake

 “Cross-Platform Makefile Generator” (source: man cmake)


 Created by a company called Kitware about 17 years ago
 Gained popularity in the last 3-4 years
 Open source software, like most good development tools
 Popular = StackOverflow compatible
 Replaces configuration utilities like autotools
Capabilities – cross-platform

 Runs on Linux, Windows, Mac OSX


 Can compile for Linux, Windows, Mac OSX

 Executable/binary format
 Path separators
 Platform-dependent libraries
Capabilities – in-place & out-of-place

 In-place (in-tree): objects files and binaries mixed with source


 Easy to do

 Out-of-place (out-of-tree): build artifacts gathered in a dedicated


directory
 Easy to force a clean build
 Multiple builds in same repo
Capabilities

 Mostly C/C++, supports other languages


 Supports using multiple toolkits
 Supports static and dynamic library builds
 Uses build tools native to the environment
 Has a graphical interface
 Extendable via macros, functions and modules
Build process

1. Generate standard build files from platform independent


configuration files.
 CMakeLists.txt files in every directory.
2. Perform the actual build using native tools.
 Usually make, gcc, msvc++, whatever the platform has.

cmake make + gcc

CMakeLists.txt Makefile Binary


Contents

 Introduction
 Definitions
 CMake
 Example
 CMake as a language
 Other command line tools
 Ninja
 Tying it all together
A simple example

<project_root>
|--build
|--inc
| `--<header files>
`--src
|--main.cc
`--CMakeLists.txt
A simple example
<project_root>/src/CMakeLists.txt:
Adding a library
<project_root>
|--build
|--inc
| `--<header files>
|--src
| |--main.cc
| `--CMakeLists.txt
`--graphics
|--inc
| `--<library header files>
|--src
| |--bells.cc
| |--whistes.cc
| `--CMakeLists.txt
`--CMakeLists.txt
Adding a library
<project_root>/src/CMakeLists.txt:
Adding a library
<project_root>/graphics/CMakeLists.txt:
Adding a library
<project_root>/graphics/src/CMakeLists.txt:
Using the example

cd <project_root>/build
cmake ../src && make

 Binaries by default go into the directory where you start cmake


 The argument is the directory where the starting CMakeLists.txt lives
Contents

 Introduction
 Definitions
 CMake
 Example
 CMake as a language
 Other command line tools
 Ninja
 Tying it all together
Variables
Variables
Lists
Lists
Conditionals
Conditionals
Formatting
Other rules
Everything else

 Iteration: foreach(), while()


 Platform inspection: check_function_exists()
 Reuse: add_custom_command(), macro(), function()
 Extension: include() files from CMAKE_MODULE_PATH

Now you know how to read the documentation


Contents

 Introduction
 Definitions
 CMake
 Example
 CMake as a language
 Other command line tools
 Ninja
 Tying it all together
CTest

Test driver for unit and component tests

1. Add enable_testing() to your listfile


2. Add testcases with add_test()
3. Run your tests with ctest
4. ???
5. Profit!
CPack

 Installation: install_*() commands

 Distribution: include(CPack), cpack_*() commands


 tar.gz, zip, deb, rpm, etc.
 cpack --config <your_config>.cmake
Contents

 Introduction
 Definitions
 CMake
 Example
 CMake as a language
 Other command line tools
 Ninja
 Tying it all together
Ninja

Small build system with a focus on speed

 Generated input
 Still human-readable
 Prefer speed over convenience
 Do one thing, and do it well
How?

 Dependency of files as input


 No unnecessary decisions
 Compilers?
 Compiler flags?
 Debug or release?
 The bare minimum to describe dependency graphs
 Ninja doesn't know about your language
Features

 Multiplatform
 Very fast when there's nothing to do
 Think “incremental build”
 One environment variable: NINJA_STATUS
 Controls the output’s format
Some more nice features

 Outputs depend on the command line


 Changing the compilation flags will cause a rebuild
 Builds are parallel by default
 Need correct dependencies
 Run ninja with nice
 Command output is buffered
How to write your own build.ninja files

 Don't
build.ninja syntax

 variables (aliases for strings)


<variable> = <value>

 build statements (how to do things)


build <outputs>: <rulename> <inputs>

 rules (what things to do)


rule <rulename>
<variable> = <value>
<variable> = <value>
Example build.ninja

cflags = -Wall

rule cc
command = gcc $cflags -c $in -o $out

build foo.o: cc foo.c


Contents

 Introduction
 Definitions
 CMake
 Example
 CMake as a language
 Other command line tools
 Ninja
 Tying it all together
Tying it all together

 CMake supports multiple generators

cmake –G “Unix Makefiles”


cmake –G “Ninja”

 Makefiles work well, but Ninja was designed for this


Summary

 Speed: handled by Ninja


 Flexibility: provided by CMake
 Reliability: both seem to be reliable so far

 Use CMake with Ninja


 Look for better alternatives for existing tools
Thanks for listening & Questions
Contact me at [email protected]

You might also like