Book Image

C++ System Programming Cookbook

By : Onorato Vaticone

Book Image

C++ System Programming Cookbook

By: Onorato Vaticone

Overview of this book

C++ is the preferred language for system programming due to its efficient low-level computation, data abstraction, and object-oriented features. System programming is about designing and writing computer programs that interact closely with the underlying operating system and allow computer hardware to interface with the programmer and the user. The C++ System Programming Cookbook will serve as a reference for developers who want to have ready-to-use solutions for the essential aspects of system programming using the latest C++ standards wherever possible. This C++ book starts out by giving you an overview of system programming and refreshing your C++ knowledge. Moving ahead, you will learn how to deal with threads and processes, before going on to discover recipes for how to manage memory. The concluding chapters will then help you understand how processes communicate and how to interact with the console (console I/O). Finally, you will learn how to deal with time interfaces, signals, and CPU scheduling. By the end of the book, you will become adept at developing robust systems applications using C++.

Preface

Who this book is for

What this book covers

To get the most out of this book

Getting Started with System Programming

Getting Started with System Programming

Technical requirements

Learning the Linux fundamentals - architecture

Learning the Linux fundamentals - shell

Learning the Linux fundamentals - users

Using a makefile to compile and link a program

Using GDB to debug a program

Learning the Linux fundamentals - processes and threads

Handling a Linux bash error

Handling Linux code error

Free Chapter

Revisiting C++

Technical requirements

Understanding C++ primitive types

Lambda expressions

Automatic type deduction and decltype

Learning how atomic works

Learning how nullptr works

Smart pointers – unique_ptr and shared_ptr

Learning how move semantics works

Understanding concurrency

Understanding the filesystem

The C++ Core Guidelines

Adding GSL in your makefile

Understanding concepts

Learning how Ranges work

Learning how modules work

Dealing with Processes and Threads

Dealing with Processes and Threads

Technical requirements

Starting a new process

Killing a process

Creating a new thread

Creating a daemon process

Deep Dive into Memory Management

Deep Dive into Memory Management

Technical requirements

Learning automatic versus dynamic memory

Learning when to use unique_ptr, and the implications for size

Learning when to use shared_ptr, and the implications for size

Allocating aligned memory

Checking whether the memory allocated is aligned

Dealing with memory-mapped I/O

Dealing with allocators hands-on

Using Mutexes, Semaphores, and Condition Variables

Using Mutexes, Semaphores, and Condition Variables

Technical requirements

Using POSIX mutexes

Using POSIX semaphores

POSIX semaphores advanced usage

Synchronization building blocks

Learning inter-thread communication with simple events

Learning inter-thread communication with condition variables

Pipes, First-In First-Out (FIFO), Message Queues, and Shared Memory

Pipes, First-In First-Out (FIFO), Message Queues, and Shared Memory

Technical requirements

Learning the different types of IPC

Learning how to use the oldest form of IPC – pipes

Learning how to use FIFO

Learning how to use message queues

Learning how to use shared memory

Network Programming

Network Programming

Technical requirements

Learning the basics of connection-oriented communication

Learning the basics of connectionless-oriented communication

Learning what a communication endpoint is

Learning to use TCP/IP to communicate with processes on another machine

Learning to use UDP/IP to communicate with processes on another machine

Dealing with endianness

Dealing with Console I/O and Files

Dealing with Console I/O and Files

Technical requirements

Implementing I/O to and from the console

Learning how to manipulate I/O strings

Working with files

Dealing with Time Interfaces

Dealing with Time Interfaces

Technical requirements

Learning about the C++ time interface

Using the C++20 calendar and time zone

Learning the Linux timing

Dealing with time sleep and overruns

Managing Signals

Managing Signals

Technical requirements

Learning all of the signals and their default actions

Learning how to ignore a signal

Learning how to trap a signal

Learning how to send a signal to another process

Scheduling

Technical requirements

Learning to set and get a scheduler policy

Learning to get the timeslice value

Learning how to set a nice value

Learning how to yield the processor

Learning about processor affinity

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Technical requirements

To try out the programs in this chapter, we've set up a Docker image that contains all the tools and libraries we'll need throughout this book. It is based on Ubuntu 19.04.

To set it up, follow these steps:

Download and install Docker Engine from www.docker.com.
Pull the image from Docker Hub: docker pull kasperondocker/system_programming_cookbook:latest.
The image should now be available. Type in the following command to view the image: docker images.

You should have the following image: kasperondocker/system_programming_cookbook.
Run the Docker image with an interactive shell with the help of the docker run -it --cpu-rt-runtime=95000 --ulimit rtprio=99 --cap add=sys_nice kasperondocker/system_programming_cookbook:latest /bin/bash command.
The shell on the running container is now available. Use...