Cmake Ninja

CMake & Ninja
by István Papp
istvan.papp@ericsson.com
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
 Ninja
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
 Ninja
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
 Ninja
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
 Ninja
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
 Ninja
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>
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
 Ninja
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 istvan.papp@ericsson.com

Cmake Ninja

Uploaded by

Copyright:

Available Formats

Cmake Ninja

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cmake Ninja

Uploaded by

Copyright:

Available Formats

CMake & Ninja

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

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

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

 Get from source* to binary*

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

*Build step: zip, upload/download, compilation

 Large variety of tasks

 Source code in multiple directories

 Make is very generic

 We can do better now

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

 Runs on Linux, Windows, Mac OSX

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

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

 Mostly C/C++, supports other languages

1. Generate standard build files from platform independent

cmake make + gcc

CMakeLists.txt Makefile Binary

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

 Iteration: foreach(), while()

Now you know how to read the documentation

Test driver for unit and component tests

1. Add enable_testing() to your listfile

 Installation: install_*() commands

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

Small build system with a focus on speed

 Dependency of files as input

 Outputs depend on the command line

 variables (aliases for strings)

 build statements (how to do things)

 rules (what things to do)

build foo.o: cc foo.c

 CMake supports multiple generators

cmake –G “Unix Makefiles”

 Makefiles work well, but Ninja was designed for this

 Speed: handled by Ninja

 Use CMake with Ninja

You might also like