Embed Files to C++ at Compile Time

Wed, 11 Dec 2024 11:00:38 -0800

This article will guide you through how to embed binary/text files to C++ as a char array, like the convenient go:embed command.

We will focus on C23 #embed, it is supported from GCC 15 and Clang 19. Note that this feature need new compiler but doesn’t need new standard, you don’t have to compile your code with -std=c++23, -std=c++17 is enough.

For other approach of embedding, refers to:

Embed Files To C++

Step 1 - Install Clang 19 or Newer Version

# install clang 20 in ubuntu
wget https://apt.llvm.org/llvm.sh
chmod u+x llvm.sh
sudo ./llvm.sh 20
# or one line: wget -qO- https://apt.llvm.org/llvm.sh | bash -s -- 20

# verify
clang-20 --version

Step 2 - Embed Files Easily

Create two files in a same directory:

Context Switch - libtask by Russ Cox

Thu, 02 Dec 2021 16:57:10 +0800

Intro

libtask is a coroutine library that has cooperative scheduler and channel built-in. The channel is a multi-sender multi-receiver structure that could be used for synchronization and data transferring between coroutines.

We will use “task” to refer to “coroutine” in the following for coherency.

Internal

overview of running procedure

There are 4 exclusive states for any task given:

running
suspended, put in the task queue
suspended, put in a channel’s sender queue or receiver queue
terminated

The program exit in 2 situations:

Context Switch - A Coroutine Library Back to 1999

Thu, 18 Nov 2021 16:08:10 +0800

Introduction

COROUTINE is a C++ library for coroutine sequencing, which Keld Helsgaun published in May 1999.

Coroutine primitives & state

The facilities of the library are based on the coroutine primitives provided by the programming language SIMULA.

Resume(Coroutine *Next) : resume the execution of a coroutine
Call(Coroutine *Next) : start the execution of a coroutine

The execution procedure of Resume and Call are the same: 1. suspending the current thread, 2. executing(start/resume) the target thread. The only difference between them is that the Call will Establish a relationship between caller and callee, whereas the Resume doesn’t.

Context Switch - Function Calling

Thu, 11 Nov 2021 16:12:30 +0800

Although the function calling was not summarized into the category of context switch generally, it is still a great choice to learn function calling as a warm-up.

(image source: cpp20-coroutine-under-the-hood)

A Simple Example

The function calling gives a promise which the changes to variable doing by the callee would not take effect of the caller (unless deliberately or the variables of callee and caller point to the same memory location).

Context Switch - Preface & Outline

Fri, 05 Nov 2021 11:43:00 +0800

Preface

I will write a series of posts about the context switch. Aiming to answer these questions:

What is a context switch?
When we need to switch context?
What’s a process / thread / coroutine(user-space thread)?
Applicable scenarios for each option.
Digging into some coroutine libraries, the pros and cons of each.
- boost coroutine
- marl
- co
- libtask
- bthread
- goroutine
- libuv
- libco
- libaco
- boos::fiber
Why X uses coroutine? (e.g: gateway, crawler)
Why X not use coroutine? (e.g: mysql)
Why linux (and other os) doesn’t have coroutine built-in?
why system call is slow/expensive?