home - SHRIK3 on SHRIK3

checklist for learning programming language

i@shrik3.com (SHRIK3) — Wed, 25 Feb 2026 15:02:25 +0100

§ the language

keywords
primitive types
- integer, float, string, array, slice, pointer…
- numerics
- boolean & operators
composite types (class, struct …)
control-flow: if, switch-case, while, for
variable: type, allocation, mutability, lifetime, static, const, scope, atomic
function declaration: type, inline, lambda…

§ the runtime

garbage collection
stacktrace

§ standard library

io, file, format and log
networking
crypto (?)

§ package management and module system

§ toolchain and build system

compiling unit and linking

Synchronisationbegriffe - WIP

i@shrik3.com (SHRIK3) — Tue, 11 Nov 2025 13:45:16 +0100

Entschuldigung für mein kaputtes Deutsch. :)

Die Hauptfrage ist, was die Anforderungen für eine korrekte Synchronisationsimplementierung (z.B. eines Locks) sind?

Es gilt die Regel, dass zwei Dinge erfüllt sind, nämlich Sicherheit und Lebendigkeit. Dass problem ist jedoch, dass diese Dinge oft mit unterschiedlichen Begriffen und Kategorisierungen difiniert werden, besonders whenn es darum geht, die englische und deutsche Literatur abzugleischen.

Sicherheit (Wechselseitiger Ausschluss / Mutual Exclusion)

Koodinierung der Abläufe der beteiligten Prozesse, sodass die kritischen Abschnitte jeweils nur von einem Prozess betreten werden können.¹
Consider N computers, each engaged in a process which, for our aims, can be regarded as cyclic. In each of the cycles a so-caled “critical section” occurs and the computers have to be programmed in such a way that at any moment only one of these N cyclic processes is in its critical section.²

Vorlesung Betriebssysteme und Sicherheit, TU Dresden, OS. ↩︎
E. W. Dijkstra. 1965. Solution of a problem in concurrent programming control. Commun. ACM 8, 9 (Sept. 1965), 569.
https://doi.org/10.1145/365559.365617 ↩︎

process, thread, task

i@shrik3.com (SHRIK3) — Mon, 27 Oct 2025 17:30:14 +0100

§ general [2]

Tanenbaum:

A process is just an instance of an executing program, including the current values of the program counter, registers, and variables. Conceptually, each process has its own virtual CPU.

§ linux specific [1]

§ difference between process and thread

§ process group

§ reference

[1] W. Mauerer, “Linux® Kernel Architecture”.
[2] A. S. Tanenbaum and H. Bos, Modern operating systems, 4. ed. Boston: Prentice Hall, 2015.

The Nucleus of a Multiprogramming System

i@shrik3.com (SHRIK3) — Tue, 21 Oct 2025 15:05:52 +0200

Per Brinch Hansen, The nucleus of a multiprogramming system.¹ ;pretty much the paper the started microkernels … but it’s not a microkernel itself

Abstract:

This paper describes the philosophy and structure of a multiprogramming system that can be extended with a hierarchy of operating systems to suit diverse requirements of program scheduling and resource allocation. The system nucleus simulates an environment in which program execution and input/output are handled uniformly as parallel, cooperating processes. A fundamental set of primitives allows the dynamic creationg and control ofa hierarchy of processes as well as the communication among them.

The purpose of the system nucleus is to implement these fundamental concepts: simulation of processes; communi- cation among processes; creation, control, and removal of processes.

§§ “precise meaning” to the process concept

distinction between internal (~=program execution) and external processes (I/O).

§§ synchronization primitives and IPC

semaphore alone does suffice (safety and efficiency)
message buffering within system nucleus as basic means of IPC.
system nucleus adminsters a common pool of message buffers and message queue for each process.

IPC primitives:

// note Fortran, in/out parameters; you have to guess :)
send_message(receiver, message, buffer), // block/non-block (queued buffers)
wait_message(sender, message, buffer),   // blocks
send_answer(result, answer, buffer),     // non-block
wait_answer(result, answer, buffer),     // blocks

send_message copies a message into the first available buffer within the pool and delivers it in the queue of a named receiver. The receiver is activated if it is waiting for a message. The sender continues after being informed of the identity of the message buffer.

wait_message delays the requesting process until a message arrives in its queue. When the process is allowed to proceed, it is supplied with the name of the sender, the contents of the message, and the identity of the message buffer. The buffer is removed from the queue and made ready to transmit an answer.

send_answer copies an answer into a buffer in which a message has been received and delivers it in the queue of the original sender. The sender of the message is activated if it is waiting for the answer. The answering process continues immediately

wait_answer delays the requesting process until an answer arrives in a given buffer. On arrival, the answer is copied into the process and the buffer is returned to the pool. The result specifies whether the answer is a response from another process or a dummy answer generated by the system nucleus in response to a message addressed to a nonexisting process.

regard the selection of a buffer as the creation of an identification of a conversation
the buffer (communication channel) is protected and exclusive to the pair.
queued messages undisturbed on the removal of their sender processes. Nucleus returns buffers to pool when answered.
(reverse: ) on removal of a process, systems check for unanswered messages sent to the process and return dummy answers to the sender.
it’s always the client who pays for the resource (i.e. buffer) during IPC. server only needs to reply (reusing sender buffer) instead of allocating one of its own

§§ dynamic creation, control and removal of processes

difference to actual microkernel (I mean, l4re)?

parent has full control over its (direct?) children (the mandated hierarchy doesn’t seem to be micro-kernel-ish)
every process can talk to each other (same namespace?)
address space isolation? paging?
async IPC (vs. l4)
not yet the “capability” concept
global buffer pool, instead of UTCB

Per Brinch Hansen. 1970. The nucleus of a multiprogramming system. Commun. ACM 13, 4 (April 1970), 238–241. https://doi.org/10.1145/362258.362278 ↩︎

GNU toolchains

i@shrik3.com (SHRIK3) — Mon, 20 Oct 2025 17:24:48 +0200

§§ every damn single GNU toolchain binary

NOTE:

<m>     - placeholder for machine tuple e.g. x86_64-linux-gnu
<v>   - placeholder for toolchain (gcc) version

GCC, under /usr/bin; Sometimes they are prefixed with machine tuples. Archlinux is x86_64 exclusive, therefore the prefixes are not necessary.

And, gcc seemingly overlaps binutils. Some of those are wrappers (see below)

From binutils:

compile stuffs:---
as              the assembler
ld              the linker. ld.bfd and ld.gold are two different
                implementation of ld. ld points to either of them
ld.bfd          "Binary File Descriptor". The older one. More support
                and compatability
ld.gold         "Gold". Newer, faster linker
objcopy         copy and translate object files / bin formats

combine stuffs:---
ar              handle archives;
                mostly, combine .o files into single .a
                linker could extract desired .o from .a
dwp             conbine DWARF object files (dwo) into single package
ranlib          generate index into archive

poke stuffs:------
strip           remove symbols, debug info etc. from obj files
elfedit         update header and program property of elf files

print stuffs:-----
objdump         display info about object files + dissambly
readelf         display info about elf files
addr2line       addr or symbol+offset into file + line number
c++filt         demangle c++ (and java) symbols
nm              list symbols from object files (+sizes)
size            list section size and total size of binary
strings         show printable chars in files

From gcc:


The "frontend" under /usr/bin
They are the user-facing programs that you may call directly

gcc             the GNU compiler "collection" all-in-one tool
cc              alias to (or same as) gcc
c89, c99        gcc wrappers with std=c89/99

g++             gcc with c++
c++             alias to (or same as) g++

cpp             C preprocessor

gcc-ar          wrapper of ar w/ --plugin=/../liblto_plugin.so
gcc-nm          wrapper of nm w/ liblto plugin
gcc-ranlib      wrapper of ranlib w/ liblto plugin

gcov            coverage testing tool
gcov-tool       offline gcda profile processing tool


The "backends" under /usr/lib/gcc/<m>/<v>/
They are internal binaries called by tools like gcc. You don't call it directly

cc1             the C Compiler
cc1plus         the C++ Compiler
collect2        wrapper of ld (from binutils); also wrapps around lto?
lto1            collect2 invokes it if -flto is enabled (indirectly via ld?)
lto-wrapper     called by collect2 ...  (ok this is twisted...but I won't worry
                about this level of "details")

Also check gcc/Makefile (configure first)

§§ misc:

Also gprof stuffs from binutils

gprof stuffs:

gp-archive
gp-collect-app
gp-display-html
gp-display-src
gp-display-text
gprof
gprofng
gprofng-archive
gprofng-collect-app
gprofng-display-html
gprofng-display-src
gprofng-display-text

comments from gcc/collect2.cc

/* !!! When GCC calls collect2, it does not know whether it is calling collect2
 *  or ld. So collect2 cannot meaningfully understand any options except those ld
 *  understands. If you propose to make GCC pass some other option, just imagine
 *  what will happen if ld is really ld!!!
*/

C Runtime

i@shrik3.com (SHRIK3) — Mon, 20 Oct 2025 10:56:41 +0200

Mixing content from:

Understanding the C Runtime: crt0, crt1, crti, and crtn
https://www.inferara.com/en/blog/c-runtime/
Documentation from ulibc
https://github.com/kraj/uClibc/blob/master/docs/crt.txt
gcc docs
http://gcc.gnu.org/onlinedocs/gccint/Initialization.html

crt0.o / crt*.o the startup objects

Historically crt0.o (C Runtime Zero). Modern toolchains split crt0 and use crt1.o (the primary startup object).

crt1.o : entry point; provides _start symbol
crti.o : initialization; prologues of .init and .finit sections
crtn.o : termination; epilogue of .init and .finit sections

crt1 Variants

Scrt1.o : used in place of crt1.o to generate PIEs
gcrt1.o : used in place of crt1.o to generate profiling info. (see gprof)
Mcrt1.o : like gcrt1.o; for prof; useless on Linux
grcrt1.o, rcrt1.o : wtf

C++ constructor stuffs, I guess

crtbegin{,S,T}.o to find start of constructors (gcc); S for shared objects/PIEs. T for static executables.
crtend{,S}.o : find start of destructors (gcc);

Instead of function calls, the startup objects are concatenated at link time.

General linking order:

crt1.o crti.o crtbegin.o [-L paths] [user objects] [gcc libs] [C libs] [gcc libs] crtend.o crtn.o

typical file locations

/usr/lib/{Scrt1, crt1, crti, crtn, gcrt1}.o
/lib64/gcc/<m>/<v>/ : crtbegin, crtend , etc.

notes

entry point + crt1.o / crt0.o

The crt0 / crt1 provides the entry point _start for the binary loader.

initialization + crti.o

stack initialization, if not done by the kernel
set up memory (data, BSS)
prepare argc, argv for main
invoking constructors for global/static objects (C++)
library initialization
then calls main(argc, argv, envp)

cleanup + crtn.o

when main returns, calls OS exit routines (e.g. _exit)

$ readelf -s /usr/lib/crt1.o 
Num: Value  Size  Type   Bind   Vis      Ndx Name
 0: [...]    0   NOTYPE  LOCAL  DEFAULT  UND 
 1: [...]    0   SECTION LOCAL  DEFAULT    1 .text
 2: [...]    5   FUNC    GLOBAL HIDDEN     1 _dl_relocate_sta[...]
 3: [...]   38   FUNC    GLOBAL DEFAULT    1 _start
 4: [...]    0   NOTYPE  GLOBAL DEFAULT  UND main
 5: [...]    0   NOTYPE  WEAK   DEFAULT   11 data_start
 6: [...]    4   OBJECT  GLOBAL DEFAULT    3 _IO_stdin_used
 7: [...]    0   NOTYPE  GLOBAL DEFAULT  UND __libc_start_main
 8: [...]    0   NOTYPE  GLOBAL DEFAULT   11 __data_start

$ readelf -s /usr/lib/crti.o 
Symbol table '.symtab' contains 4 entries:
Num: Value  Size  Type   Bind   Vis      Ndx Name
 0: [...]    0   NOTYPE  LOCAL  DEFAULT  UND 
 1: [...]    0   NOTYPE  WEAK   DEFAULT  UND __gmon_start__
 2: [...]    0   FUNC    GLOBAL HIDDEN     5 _init
 3: [...]    0   FUNC    GLOBAL HIDDEN     7 _fini

container, k8s, docker, podman

i@shrik3.com (SHRIK3) — Mon, 08 Sep 2025 15:46:46 +0200

§ podman

Install: https://https://podman.io/docs/installationodman.io/docs/installation

archlinux setup + LUKS + LVM

i@shrik3.com (SHRIK3) — Fri, 22 Aug 2025 15:04:08 +0200

system setup:

LUKS + LVM + (ext4) + archlinux. This is for experienced arch user. For detailed guide on arch installation please use archwiki

and

https://shrik3.com/post/archlinux/arch_setup_new/

                partition overview                         overview

NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS lsblk nvme0n1 259:0 0 953.9G 0 disk ├─nvme0n1p1 259:1 0 1G 0 part /boot └─nvme0n1p2 259:2 0 900G 0 part └─cryptlvm 253:0 0 900G 0 crypt ├─lvmroot-root 253:1 0 250G 0 lvm / ├─lvmroot-home 253:2 0 600G 0 lvm /home └─lvmroot-swap 253:3 0 48G 0 lvm [SWAP]

FS dev mappers mappers

/dev/mapper/lvmroot-root -> / /dev/mapper/lvmroot-home -> /home /dev/mapper/lvmroot-swap -> swapon

                luks PART I - init                        luks init

create the luks partition create

$ cryptsetup -v -y \ # verbose, ask password -c aes-xts-plain64 \ # cypher, default for LUKS2 -s 512 -h sha512 \ # key size, hash algo -i 2000 \ # 2 seconds to process pw –use-random \ # RNG –label=SOME_LABEL \ # .. luksFormat –type luks2 \ # format w/ luks2 /dev/nvme0n1p2 # the device

dump information of the luks partition luks info

$ cryptsetup luksDump /dev/nvme0n1p2

backup the luks headers (and save it to safe place) luks backup

$ cryptsetup luksHeaderBackup –header-backup-file
/a/path/header.img /dev/nvme0n1p2

manually open the luks device: luks open dev

$ cryptsetup open [–type luks2] /dev/nvme0n1p2 cryptlvm

                lvm setup                                 lvm setup

(first open the luks partition via cryptsetup open!)

create lvm physical volume and volume group open crypt dev

$pvcreate /dev/mapper/cryptlvm$ vgcreate lvmroot /dev/mapper/cryptlvm

create virtual partitions lvm partations

$lvcreate -L250G lvmroot root$ lvcreate -L650G lvmroot home $ lvcreate -L48G lvmroot swap

                file system                                      fs

mkfs.vfat -F32 /dev/nvme0n1p1 # the unencrypted part! mkfs.ext4 /dev/mapper/lvmroot-root # root mkfs.ext4 /dev/mapper/lvmroot-home # home mkswap /dev/mapper/lvmroot-swap # swap

mount the disks (see the overview above)

$mount /dev/mapper/lvmroot-root /mnt$ mkdir /mnt/boot /mnt/home $mount /dev/mapper/lvmroot-home /mnt/home$ mount /dev/nvme0n1p1 /mnt/boot

                system setup (as always)                  sys setup

install the base system $ pacstrap -K /mnt base linux ….
generate $ genfstab -U /mnt » /nnt/etc/fstab
chroot into /mnt $ arch-chroot /mnt
set timezone, locale etc. $ skip

config hostname, users etc.

              bootloader                                bootloader

mkinitcpio config mkinitcpio

/etc/mkinitcpio.conf HOOKS = … add [encrypt, lvm2] before [filesystems]

regenerate init image

$ mkinitcpio -P

grub config (install grub and efibootmgr first) grub

install grub

$ grub-install –target=x86_64-efi
–efi-directory=/boot
–bootloader-id=meow
–recheck

edit config: /etc/default/grub

§ add to GRUB_CMDLINE_LINUX:

cryptdevice=UUID=:cryptlvm root=/dev/lvmroot/root

generate grub config

$ grub-mkconfig -o /boot/grub/grub.cfg

                references

https://jadarma.github.io/blog/posts/2024/08/installing-nixos-with-flakes-and-lvm-on-luks/ https://gist.github.com/mjnaderi/28264ce68f87f52f2cabb823a503e673

vi: ts=2 vi: tw=72 vi: ft=text

nix 01 - Nix subsystem for arch

i@shrik3.com (SHRIK3) — Sun, 03 Aug 2025 18:24:28 +0200

[BACK TO INDEX]

With massive copy-paste from the Nix Pills. This post is under the same CC-BY-SA-4.0 . (Co-)Authors list.

This post is intended to be a quick reference for arch-to-nix beginner (me).

§ Nix Subsystem for Arch

I’m learning and playing with nix to decide if I should hop to NixOS for my new work laptop.

arch install

# insteall `nix` for archlinux (native)
pacman -S nix
systemctl enable --now nix-daemon.service

env. variables

export PATH=$HOME/.nix-profile/bin:$PATH
# I prefer the nixos channel instead of the unstable.
# otherwise it could be:
# export NIX_PATH=`nixpkgs=channel:unstable`
export NIX_PATH=`nixpkgs=channel:nixos`

install nix (again?) well, because from this point I’ll use nix as a self-contained unit independent of the arch system package. Also this won’t work if you use the unstable channel

nix-channel add  https://nixos.org/channels/nixos-25.05
nix-channel --update
nix-env -iA nix

environment: The user environment is defined by manifest.nix.. I don’t think it’s meant to be human readable.. Uninstalling from the environment doesn’t remove the package itself. (If I understand correctly it simply creates a new generation that has no package).

$ nix-env -e '*'    # danger, this removes everything from the env

to undo this, manually locate the nix-env binary and rollback.

/nix/store/q7v3i9ii8mp6pjasxwip4ybq79hzxj1q-nix-2.28.4/bin/nix-env --rollback

channels

frequently used commands

nix-env -iA <pkg>           # install pkg for (all) users

# Queries
nix-env --list-generations
nix-env -q                  # query installed packages
nix-env -q --out-path       # also shows their _actual_ locations
nix-env --rollback          # rollback to the previous generation

# The argument points to something in the nix-store
nix-store -q --references $(which hello)  # runtime dependencies of hello
nix-store -qR [...]                       # the closure, recursive deps
nix-store -q --tree [...]                 # closure in tree display
nix-store -q --referrers  $(which hello)  # the reverse dependencies of hello

Caveats

they recommand you to use the unstable channel but this can be very broken. For example the manpages are missing.
Never ever try to manually modify /nix/store/*

test

i@shrik3.com (SHRIK3) — Mon, 28 Jul 2025 12:49:57 +0200

e^{i \pi} + 1 = 0

Memory Jargons

i@shrik3.com (SHRIK3) — Tue, 22 Jul 2025 12:04:15 +0200

/proc/meminfo (free)

$ man proc_meminfo

MemTotal (total): total usable RAM i.e. total physical RAM minus reserved bits and kernel binary code.
MemAvailable: memory that can bed used if there is demand. Memory could be used for file caches by the kernel and still marked as availabe.
MemFree (free): the “free” memory per se. Memory that is not used for ANY purpose. This is roughly MemAvailable - Cache - Buffer.
Low/HighFree: amount of free Low/High memory (see notes below)
Low/HighTotal: total amount of Low/High memory

Cached In-memory cache for files read from disk (excl. SwapCached)

Buffers TODO

SwapTotal/Free Amount of total/free swap space

SwapCached Memory that once was swapped out, is swapped back in but still also is in the swap file. (If memory pressure is high, these pages don’t need to be swapped out again because they are already in the swap file. This saves I/O.)

Active / Inactive; also for anon and file Memory recently (/ less) used; ususally not (/ more eligible) to reclaim.

Unevictable

MLocked

used: memory in use
free: memory not in use
shared
buffers
cached
shared / buffers / cached values are included in used

Low and High memory

dogma: with paging enabled, the OS can only access memory via virtual address.

This is rather a legacy term. 32bit kernel can address 2^32 = 4GiB of virtual memory. A typical config is that kernel takes upper 1GiB and user takes lower 3GiB. The kernel can map ~860 MB of physical memory; Physical memory above this line is highmem. Access to highmem requires temporary mapping and is slower.

In contrast, 64bits kernel has a virtual memory space (48 bits = 256 TB) much larger than physical memory, the kernel can map the whole available physical address space to its virtual address space via a fixed mapping e.g.

    VA = PA + offset

/proc/status

$ free -h

      total   used   free  shared  buff/cache  available
Mem:   15Gi  9.7Gi  2.1Gi   2.9Gi       6.8Gi      5.7Gi
Swap:  15Gi  725Mi   15Gi

$ cat /proc/<pid>/ status # only showing memory related

Name:       systemd
VmPeak:    31296 kB
VmSize:    23560 kB
VmLck:         0 kB
VmPin:         0 kB
VmHWM:     20864 kB
VmRSS:     14244 kB
RssAnon:    4948 kB
RssFile:    9296 kB
RssShmem       0 kB
VmData:     4464 kB
VmStk:       132 kB
VmExe:        56 kB
VmLib:     12112 kB
VmPTE:        92 kB
VmSwap:      424 kB
HugetlbPages:  0 kB
Mems_allowed:   [SNIP]
Mems_allowed_list:  0

RDMA 101 - libverbs APIs and hello world

i@shrik3.com (SHRIK3) — Mon, 21 Jul 2025 20:28:23 +0200

Introduction to Programming Infiniband RDMA by Insu Jang
https://insujang.github.io/2020-02-09/introduction-to-programming-infiniband/

Code

https://github.com/Arlu/RDMA-Hello-World

Copy-Verbatim, all rights belong to the original author(s)

RDMA 101 - basics

i@shrik3.com (SHRIK3) — Mon, 21 Jul 2025 13:51:12 +0200

SRC: Netdev 0x16: RDMA Tutorial by Roland Dreier (Enfabrica) and Jason Gunthorpe (NVIDIA)
https://netdevconf.info/0x16/slides/40/RDMA%20Tutorial.pdf

Introduction to Programming Infiniband RDMA by Insu Jang
https://insujang.github.io/2020-02-09/introduction-to-programming-infiniband/

Code

https://github.com/linux-rdma/rdma-core

Copy-Verbatim, all rights belong to the original author(s)

Async queues:

work requests are sent to send/recv queues
poll completion queue for completion

One-sided operations (RDMA): one host moves data directly to or from memory of its communication peer without notifying its CPU
Two-sided operations: (1) one host posts a receive work request (2) peer posts a send work requests that consumes the recv work request to deliver data

one-/or two-sided operations can be mixed.

transport layers

Transport Layering

            [Application]
             _____|_____ 
            |           |
      [UD QPs]        [RC QPs]
            |           |
            +-----+-----+
                  |      
            [   Verbs   ]                       libverbs
                  |
  ________________|_________________
  |        |          |             |
[RoCE]  [iWARP]  [InfiniBand]  [Omni-Path]      Transport
  |________|
      |
  [Ethernet]        [IB]       [Omni-Path]      Physical

SW

librdmacm connection establishment w/ IP addressing
libverbs API for control/data path operations. “verbs” interface implementation

Lingua

Reliable Connected (RC)

Unreliable Diagram (UD)

Queue Pair (QP), Completion Queue (CQ), Send Queue (SQ), Receive Queue (RQ): SQ and RQ are always grouped and managed as a queue pair (QP). SQ and RQ in a queue pair could use distinct CQ or share one.

   CA 1                 CA 2
   ----                 ----
   SEND --------------> RECV
   RECV <-------------- SEND

Work Request (WR), Work Completion (WC): post WR by generating a work queue entry (WRE) into the work queue. e.g. SEND WR to SQ; RECV WR to RQ. Once a request is completed, the HW posts a Work Completion (WC) into a CQ.

Protection Domain (PD)

Memory Region (MR)

InfiniBand (IB)

Channel Adapter (CA): an end node in the IB network (comparable to a NIC)

Host Channel Adapter (HCA)

statistic tools - 去海边整点统计工具

i@shrik3.com (SHRIK3) — Fri, 04 Jul 2025 08:53:44 +0200

§ Mann-Kendall test for monotonic trend

https://vsp.pnnl.gov/help/vsample/design_trend_mann_kendall.htm

§ Petri Nets

Petri Nets fundamentals

https://teaching.model.in.tum.de/2021ss/petri/material/petrinets.pdf'

Stochastic Petri Nets

§ odds ratio and relative risk

Settings:

There are 2000 students in the campus. (composition shown in table)
In practice we cannot study all of the 2000 students. And we must do sampling.

Ground truth

	exercise (E)	no exercise (Ne)	Sum
Pass Exam (P)	500	700	1200
Fail Exam (F)	46	754	800
Sum	546	1454	2000

Thesis: not going to exercise increases risk of failing the exam.

A lecturer wants to study the Relative Risk of failing exam for student to do not go to exams.

\begin{aligned} RR &= \frac{F_{Ne}}{P_{Ne} + F_{Ne}} : \frac{F_{E}}{P_{E} + F_{E}}\\\\ \end{aligned}

The Art of Multiprocessor Programming - Notiz

i@shrik3.com (SHRIK3) — Thu, 03 Jul 2025 13:49:28 +0200

The Art of Multiprocessor Programming - Maurice Herlihy and Nir Shavit

Took a lecture that used this as the textbook … I think I should review it..

L4RE hands-on : build system

i@shrik3.com (SHRIK3) — Tue, 01 Jul 2025 10:16:25 +0200

REFERENCE: https://l4re.org/doc/l4re_build_system.html

L4 must be built out-of-tree

make B=<builddir>   # create build (object) dir
make O=<builddir>   # invoke make with specified object dir

to include the builddir into the makefile (or local config)

OBJ_BASE = <builddir>

BID Makefile: if I understand correctly every level of subdir should have one Makefile. Specify the role:

{project, subdir, prog, lib, include, doc, test, ldl, runux}.mk

EXAMPLE BID Makefile

PKGDIR  ?=  <>

jargons

BID:    refers to L4RE build system (but why?)

vim:textwidth=72 vim:ft=text

scams

i@shrik3.com (SHRIK3) — Sat, 28 Jun 2025 20:27:17 +0200

logging some scams I see

§§§ Fake “undelivered email” notice

an email saying:

Roundcube Found Several Undelivered Messages 6/26/2024 5:14:20 p.m. Undelivered emails for i@shrik3.com You have up to 6 hanging message on i@shrik3.com. Retreive the emails into your local folder by using the Read Undelivered Emails button Read Undelivered Email Gateway i@shrik3.com Microsoft Corporation One Microsoft Way, Redmond, WA 98052, USA

… followed by a link, obviously fishing site.

It’s pretending to be myself by faking the header

From: i@shrik3.com
To: i@shrik3.com

This email is caught by the spam filter. But … it’s surprising that the email client does not alert for either of the following things

the header claims a sender that doesn’t match the the originating server.
the DKIM signature is missing or mismatching.

Luckily (?) there is a thunderbird plugin that check DKIM….

…but are we using DKIMs at all?

I quickily went through my inbox with the newly added DKIM checker. And (not to my surprise) most emails I got (even legit ones) has no valid DKIM….

ausland

i@shrik3.com (SHRIK3) — Mon, 23 Jun 2025 17:49:51 +0200

TIMELINE RES.Status Stu.Status Contract.Status

| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |

hello

i@shrik3.com (SHRIK3) — Mon, 23 Jun 2025 17:47:36 +0200

meow

Genode and Trusted Computing

i@shrik3.com (SHRIK3) — Fri, 20 Jun 2025 13:04:29 +0200

some takeaways from Norman Feske presentation.

operating system complexity is a disease ..

define “Trust” in software

I have to try this out… https://genode.org/documentation/genode-foundations/index

Wissen führen!

i@shrik3.com (SHRIK3) — Thu, 12 Jun 2025 16:15:51 +0200

what it takes to be a scientist

- Mietvertrag mit Nachweis über die Miethöhe; Bei Untermietvertrag Zustimmung
  des Eigentümers

- vom Arbeitgeber ausgefülltes Formular >Erklärung zum Beschäftigungsverhältnis<

- Stellenbeschreibung

- Nachweis über einen deutschen oder ausländischen Hochschulabschluss inkl.
  Modulübersicht

- Arbeitsvertrag zur Ausübung einer (hoch-)qualifizierten Beschäftigung

- aktuelle Mitgliedsbescheinigung der Krankenversicherung

can I survive a month with 100 Euros for food?

i@shrik3.com (SHRIK3) — Thu, 12 Jun 2025 14:08:15 +0200

A rough “nutrition” guideline.

N       Daily   Month       avg.price (kg)          mix.avg     ~SUM
---------------------------------------------------------------------
grain   250g    7.5kg       Rice            3.5     5.5         41.25
                            var. grains     7-10     
lean    180g    5.5kg       Schweine        10                  50
meat
Veg.    300g    9kg         Gurke           0.6/stk             30
                            Salat           0.8/stk
                            Aubergine       1/stk
                            ktf             1.3
                            tmt             0.9
                            Zwiebel         2
                            Zucchini        1.4
                            Karotten        1.3
                            Rucola          8
                            Broccoli        3
                            Paprika         3.38
Fish            3kg         Lachsfilet      25
                            Herring         14
                            Garnelen        20
Geful           3kg
meat
Milk    300ml   9L          Vollmilch       1                   9
Egg     1       30          Eier            0.3                 9
Fruit   200g    6kg

Monthly Purchase

Price(sum)  Amount & unit   Name
--------------------------------------------------------------
13          5kg  bag x1     ORIENT GOURMET Jasminreis Longkorn
5.2         400g bag x2     LE LE CHU Sojabohnen 
2.5         400g bag x1     LE LE CHU Maisgriess grob 400g
2.8         400g bag x1     LE LE CHU Hirse 400 g
2           400g bag x1     GOLDEN CHEF Grüne Mungbohnen 400g
---         --------------------------------------------------
25.5        6.6kg of staple food

Weekly Balance
    - 25.5 / 4 = - 6.375

Weekly Purchase

Price(sum)  Amount & unit   Name
--------------------------------------------------------------
2.5         10 stk.         Eier aus Bodenhaltung
2           1L x 2          Milch
2.3         1.5 kg          Zwiebeln
10 (?)      1 kg            Schweinebauchscheiben
---         --------------------------------------------------
16.8

Now we have left (weekly)
    
    25 - 6.375 - 16.8 = 1.82

Weekly Plan [25 Euro]

VLIW archs

i@shrik3.com (SHRIK3) — Tue, 03 Jun 2025 19:16:53 +0200

[V]ery [L]ong [I]ncoherent [W]riteup Historical context on Groq., Irrational Analysis,
https://irrationalanalysis.substack.com/p/very-long-incoherent-writeup

http://www.vliw.org/

Embedded Computing: A VLIW Approach to Architecture, Compilers and Tools, Buch von Josh Fisher

Diffie–Hellman key exchange

i@shrik3.com (SHRIK3) — Tue, 03 Jun 2025 14:24:12 +0200

define an operation X that satisfies

Associative: a X b X c = a X (b X c)
Commutative: a X b = b X a
No (or very difficult) reverse operation. e.g. If we know a and (a X b), it’s impossible to calculate b

Key Exchange (very simplified)

        C   : common knowledge, public
        a   : secret bits, private to ALICE
        b   : secret bits, private to BOB


        ALICE                           BOB
        + a                             + b
            |                           |
            |      send A:= a X C       |
            |-------------------------->|
            |                           |
            |      send B:= b X C       |
            |<--------------------------|
            |                           |
calc.       |                           | calc.
s := B x a  |                           | s := A X b
            |                           |
            |                           |
                B x a == b X C x a
                      == a x C x b
                      == A x b

After the key exchange,

both ALICE and BOB calculate s := a X b X C (property 1 and 2). And they can use s as a symmetric key.
Attacker knows C, a X C, b X C. But can’t calculate a, b nor a X b X C (property 3)

timer interrupt

i@shrik3.com (SHRIK3) — Mon, 02 Jun 2025 13:26:29 +0200

docs:

https://www.kernel.org/doc/Documentation/timers/NO_HZ.txt

§ TIMER INTERRUPT FREQUENCY

$zcat /proc/config.gz | grep "HZ"

CONFIG_NO_HZ_COMMON=y
# CONFIG_HZ_PERIODIC is not set
# CONFIG_NO_HZ_IDLE is not set
CONFIG_NO_HZ_FULL=y
CONFIG_NO_HZ=y
# CONFIG_HZ_100 is not set
# CONFIG_HZ_250 is not set
CONFIG_HZ_300=y
# CONFIG_HZ_1000 is not set
CONFIG_HZ=300
CONFIG_MACHZ_WDT=m

learn lua (WIP)

i@shrik3.com (SHRIK3) — Mon, 02 Jun 2025 10:08:36 +0200

resources:

lua.org: programming in lua (first edition)

§ KEYWORDS


DECLARACTION
    local   function

LOGIC
    and     or  not

CONTROL
    for	    in  repeat  until   while   break
    do      if  else    elseif  then    return
    end

VALUE
    true    false   nil

§ tyles and values

basic types

nil: type of a single value, non-exist, anything undeclared, or effectively “deleted”
boolean: 2 values true and false. conditionals consider false and nil to be false and anything else to be true. nil is false, 0 is true.
number: real numbers, double-precision floating point. There is no integer type in lua. lua can represent any long integer without rounding issues. Lua can be compiled to use other types for numbers.

    4     0.4     4.57e-3     0.3e12     5e+20

string
userdata
function
thread
table

SDRAM intro

i@shrik3.com (SHRIK3) — Wed, 28 May 2025 18:48:18 +0200

Readings:

On DRAM address mapping and memory controller

Minghua Wang et.al.,DRAMDig: A Knowledge-assisted Tool to Uncover DRAM Address Mapping
https://arxiv.org/pdf/2004.02354
Marius Hillenbrand, KIT, Physical Address Decoding in Intel Xeon v3/v4 CPUs: A Supplemental Datasheet
https://os.itec.kit.edu/downloads/publ_2017_hillenbrand_xeon_decoding.pdf
Mark Seaborn, How physical addresses map to rows and banks in DRAM https://lackingrhoticity.blogspot.com/2015/05/how-physical-addresses-map-to-rows-and-banks.html

Tech specs and datasheet

Micron Datasheet: {4,8,16}Gb: x4, x8, x16 DDR4 SDRAM Features.¹
JEDEC docs
- DDR4 SDRAM (JESD79-4)
- DDR4 SDRAM Registered DIMM Design Specification

RAS, Rowhammer

§ TEXT (TAKEAWAYS)

Memory system can be orginized in {Channel, Rank, Chip, Brank Group, Bank, Array, Row/Column}.
Modern CPUs use integrated Memory Controller(s), which maps a physical address into actual DRAM cells (rank X chip X bank group X bank X row X column).
CPU can have multiple DRAM channels, each having its own memory controller and bus. Each channel can be accessed independently.
DRAM access can be interleaved on multiple level. The cpu could interleave channel/rank/bank group/bank by arranging the physical memory address mapping. This helps boosting performance.

§ DRAM HW ORGANIZATION

Channel: each channel is read by the CPU independently. The concept of “Channel” is external to DRAM (or DDR, or DIMM). It’s about how the CPU operates memory.
DIMM (Dual Inline Memory Module): the physical format of the memory stick. SO-DIMM (small outline) for laptops.
Rank: A set of DRAM chips, a unit thats offer [machine word] wide data access (say, 64 bits, or 72 bits for ECC). One rank is selected i.e. connected to the bus and accessed at a time.²
Chip (x4, x8 or x16): a single DRAM IC chip. If I understand correctly, one bank of a bank group is selected at one time.
Bank Group: each chip has multiple banks and they can be optionally organized in groups. Access to bank in a different group would be faster than sequential access to another bank in the same group. Each bank group share the same IO gating.
Bank (x4, x8 or x16): Basic unit that outputs x{4,8,16} bits at one access. Consists of #{4,8,16} arrays sharing the same row/col selection. (Actually, all active arrays/banks in the same active RANK selects the same row/colulm.
Array {Row, Column}: matric addressing unit of memory cells. The “Row” and “column” are also refered to as “word line” and “bit line”. Each array has it sense amplifier and outputs 1 bit at a time
depth and width of memory chip: width is how many bits a chip offer of the 64bit output, i.e. number of banks. it is either x4, x8 or x16. Typical configuration: 8 chips (8x each) offer 64bit. or 9 chips for 72 bits ecc. Depth is the size of the DRAM chip.

                                                                             
    ┌───────────────────────────────────────────────────────────────────┐\ 
    │ DIMM                                                              │ |
┌───────────────────────────────────────────────────────────────────┐  ┌┘ C
│ DIMM ┌─────────────────────────────────────────────────────────┐  │  └┐ H
└┐     │ ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐ │ ┌┘   │ A
┌┘     │ │CHIP│ │CHIP│ │CHIP│ │CHIP│ │CHIP│ │CHIP│ │CHIP│ │CHIP│ │ └┐   │ N
│      │ └────┘ └────┘ └────┘ └────┘ └────┘ └────┘ └────┘ └────┘ │  │  ┌┘ N
└┐     │  RANK (typically a "side" of the ram)                   │ ┌┘  └┐ E
┌┘     └─────────────────────────────────────────────────────────┘ └┐   │ L
│ ┌┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┐ │───┘ |
└─┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴─┘    /
    
    Fig.1. Channel, DIMM, RANK, and CHIP


         ┌────────────────────────────────────────────────┐   \
         │ x4, x8 or x16 arrays                           │    |
     ┌────────────────────────────────────────────────┐   │    |
     │ ARRAY                                          │   │    |
 ┌────────────────────────────────────────────────┐   │   │    |
 │ ARRAY                                          │   │   │    |
 │             ┌────┐     ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐   │   │   │    |
 │             │  S ├─────┤ │ │ │ │ │ │ │ │ │ │   │   │   │    | B
 │             │R E │     ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤   │   │   │    | A
 │             │  L ├─────┤ │ │ │ │ │ │ │ │ │ │   │   │   │    | N
 │       DEC   │O E │RSEL ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤   │   │   │    | K
 │       ┌────►│  C ├────►│0│1│2│3│T│5│6│7│8│9│   │   │   │    |
 │       │     │W T │     ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤   │   │   │    |
 │       │     │  I ├─────┤ │ │ │ │ │ │ │ │ │ │   │   │   │    |
 │       │     │  O │     ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤   │   │   │    |
 │       │     │  N ├─────┤ │ │ │ │ │ │ │ │ │ │   │   │   │    |
 │       │     └────┘     └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘   │   │   │    |
 │       │             CPY ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼    │   │   │    |
 │       │                ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐   │   │   │    |
 │       │     ROW BUFFER │0│1│2│3│T│5│6│7│8│9│   │   │   │    |
 │       │                └─┴─┴─┴─┘▲└─┴─┴─┴─┴─┘   │   │───┘    |
 │  ┌────┴────┐        DEC         │ CSEL         │   │        |
 │  │CELL ADDR├────────────────────┘              │───┘        |
 │  └─────────┘                                   │            |
 └────────────────────────────────────────────────┘           /

 T   : target cell (bit)
 RSEL: row selection
 CSEL: column selection
 DEC : address decoder
 CPY : transfer into row buffer (this is destructive)
 ROW BUFFER : aka. sense amplifier

    Fig.2. DRAM Bank, Array and Row-Column Addressing

In-Array addressing:

Address is broken into row and column; first select the row
whole row is copied into a row buffer (sense amplifiers). Then select the column (bit) and read it out. WRITE works similarly. The buffer is written back into the row regardless read/write. (destructive read)
Logically there is one row buffer per bank, in practice there are multiple, one at each subarray
all subarray in a bank share the same row and col address. i.e. reading the same cell from each array to compose x{4,8,16} bits output for the DRAM.

some notes on DIMM pins

Note that the col and row addr is multiplexed on the ADDR pins, i.e. sent in serial. ³

DDR4 288 pin DIMM has:

 A[0 :17] Address Bus (A17 is in most cases non-valid)
BA[0 : 1] Bank Select
BG[0 : 1] Bank Group Select
CS        Rank Select ... bits depends

2^( 17 + 17   + 2  +  2      +      1   )   x   8   x    8
    Row         4 groups,       2 ranks       depth    chips
    Col         4 banks each                   |_________|
                                              64bit bus (DQ)

= quite some TBs

§ ADDRESSING

Parameter               4Gb x 4         2Gb x 8         1Gb x 16
----------------------------------------------------------------------
#Bank Groups            4               4               2
BG addr                 BG[1:0]         BG[1:0]         BG0
#Bank per BG            4               4               4
Bank addr in Group      BA[1:0]         BA[1:0]         BA[1:0]
Row addressing          A[17:0] 256K    A[16:0] 128K    A[16:0] 128K
Col addressing          A[9 :0] 1K      A[9 :0] 1K      A[9 :0] 1K 

Page Size               512B            1KB             2KB

From: "Table 2: Addressing", 16Gb: x4, x8, x16 DDR4 SDRAM Features, Micron

Note Page Size. Pagesize indicates the size of all row buffers of the active bank. (Locality) sequentially accessing the same page is faster, because all subsequent data is already in the buffers (no need for another ACTIVATE command)

Page size is supposed to be multiple of cache line size.

Page Size = (ColSize) x ORG / 8
ORG       = number of DQ bits, i.e. 4/8/16

§ DRAM COMMANDS / OPERATIONS

PRECHARGE: deactivate the open row in a particular bank, or the open row in all banks. This write buffered row back into capacitors (effectively refreshing). After PRECHARGE, a bank must be activated (again) before next READ or WRITE.
ACTIVATE + BG, BA, Addr(row), + CS (rank selected): enable access to a ROW in the specified Bank. The selected row is buffered (via sense amplifier) until PRECHARGE.
READ: read out a COLUMN. If next R/W is in a different row then READ should be followed by a PRECHARGE (or Read and Auto-Precharge command)
WRITE: like READ, but data is written into the row buffer bits. With the next PRECHARGE the data is committed to the cells. (? can I perform multiple writes to the same row and do PRECHARGE at once?)
REFRESH: keeps an internally incrementing refreshed-row counter (keeps track of the last-refreshed row). The current row of every bank is refreshed. REFRESN requrires the bank to be precharged. i.e. there is no activate row (ongoing READ/WRITE).

Most DRAMs will perform 8192 refresh cycles every 64 ms. That’s every 7.813 μ s. This has remained constant despite growing device densities. ⁴

OTHERS: NOP, Load Mode Register, Burst Terminate, Command Inhibit (Device deselect)

Burst Mode R/W

§ TIMING

                                                         CKE_L                
                                                       ┌───────┐            
                                              ┏━━━━━━━━━━━━┓   │            
                                   ┌────SRE──►┃SELF-REFRESH┃◄──┘            
                                   │          ┗━━━━━━━━━━━━┛
                             ┏━━━━━━┓          │                               
                             ┃ IDLE ┃◄──SRX────┘                               
                             ┃      ┃         ┏━━━━━━━━━━━━┓              
┌---------------------------►┃      ┃───REF──►┃            ┃
|                            ┃      ┃◄--------┃ REFRESHING ┃
|                            ┗━━━━━━┛         ┗━━━━━━━━━━━━┛
|                                │ACTIVATE                                    
|                                │                                            
|                           ┏━━━─▼─━━━━━┓                                   
|                           ┃ACTIVATING ┃   ────► command sequence
|                           ┗━━━━━━━━━━━┛   ---─► auto.   sequence
|                                |                                          
|                                |                                          
|                  WRITE_A  ┏━━━─▼─━━━━━┓                READ_A
| ┌─────────────────────────┃           ┃────────────────────────┐
| │           ┌────WRITE────┃BANK ACTIVE┃────────────┐           │
| │   WRITE   │ ┌---------─►┃           ┃◄-------─┐  │   READ    │
| │   ┌─────┐ │ |           ┗━━━━━━━━━━━┛         |  │ ┌──────┐  │
| │   │     │ │ |                 │               |  │ │      │  │
| │   │  ┏━━━━▼─▼─━━┓             │             ┏━━━─▼─━━━━┓  │  │
| │   │  ┃          ┃◄────────────┼───READ──────┃          ┃  │  │
| │   └─►┃ WRITING. ┃             │             ┃ READING. ┃◄─┘  │
| │      ┃          ┃───WRITE─────┼────────────►┃          ┃     │
| │      ┗━━━━━━━━━━┛             │             ┗━━━━━━━━━━┛     │
| │          │  │ │            PRE,PREA            │ │ │         │ 
| │          │  │ │               │                │ │ │         │ 
| │          │  │ └───────────────┼───READ_A─────┐ │ │ │         │
| │          │  │                 │              │ │ │ │         │ 
| │          │  │ ┌─────WRITE_A───┼──────────────┼─┘ │ │READ_A   │ 
| │          │  │ │               │              │   │ │         │ 
| │  WRITE_A │  └─┼───PRE,PREA─┐  │   ┌─PRE,PREA─┼───┘ │         │
| │          │    │            │  │   │          │     │         │  
| │      ┏━─▼─━━━─▼─┓        ┏─▼──▼───▼─━━┓     ┏─▼─━━━─▼─━┓     │
| │      ┃          ┃        ┃            ┃     ┃          ┃     │
| └─────►┃ WRITING. ┃------─►┃PRECHARGING ┃◄---─┃ READING. ┃◄────┘
|        ┃          ┃        ┃            ┃     ┃          ┃      
|        ┗━━━━━━━━━━┛        ┗━━━━━━━━━━━━┛     ┗━━━━━━━━━━┛      
|                                  |
|                                  |
└----------------------------------┘
                                                                                    
    Fig.3. DRAM State Diagram
    Derived From: "Figure 13: Simplified State Diagram",
    16Gb: x4, x8, x16 DDR4 SDRAM Features, Micron

§ MISC

CAS (Column Address Strobe) and RAS (Row -): CAS and RAS pin tell either row or column address is in the address line. CAS Latency measures the delay between READ command and the moment the data is available.
WE: Write Enable
CS: Chip Select

┌─────────────────────────────────────────────────┐
│                  CS    RAS    CAS    WE    ADDR │
│                ──────────────────────────────── │
│ ACTIVATE      │  L     L      H      H     Row  │
│ PRECHARGE     │  L     L      H      L          │
│ READ          │  L     H      L      H     Col  │
│ WRITE         │  L     H      L      L          │
│ REFRESH       │  L     L      L      H          │
│ NOP           │  L     H      H      H          │
│ BURST TERM.   │  L     H      H      L          │
│ LOAD MODE REG.│  L     L      L      L          │
│ COMMAND INH.  │  H     X      X      X          │
└─────────────────────────────────────────────────┘
            In this case .. Low is yes, High is No...

(shamelessly taken from Stephen’s article ⁴ (Figure 5. DRAM commands - Truth Table)

you may find them on micron website, but these may be restricted to registered user only, perhaps with a NDA. ↩︎
rank interleaving: not selected ranks go through their refresh cycles in parallel. ↩︎
for a typical memory read, first ACTIVATE command with {CS, BG, BA} and ADDR (row number). To open a row for subsequent access. Then READ command with selects and ADDR (col number). ↩︎
Executing Commands in Memory: DRAM Commands, Stephen St. Michael ↩︎ ↩︎

L4RE hands-on : language quirks (WIP)

i@shrik3.com (SHRIK3) — Tue, 27 May 2025 00:08:57 +0200

§ not quite C++

the fiasco microkernel uses some perl wichery called Preprocess. It’s basically a C++ module system from 20 years ago that looked somewhat like modern rust.

Preprocess author: Michael Hohmuth   
Preprocess is a preprocessor for C++ modules. With this tool, you write
unit-style single-source-file modules in C++.

Links

Preprocess tool from fiasco tree
Preprocess documentation
or feel free to use my aur package : yay -S preprocess-git

Takeaways

unit style single-source-file module (.cpp)
headers are generated
namespaces and nested classes not supported

mod.cpp     -> public header  : mod.h
               private header : mod_i.h
               impl. file     : mod.cc

Language Directives


INTERFACE                : INTERFACE section
IMPLEMENTATION           : IMPLEMENTATION section
IMPLEMENTATION [suffix]  : specify the output file (.cc) suffix.
                           CONFLICTS with -e (cond. compilation)

INTERFACE [tag-expression]
IMPLEMENTATION [tag-expression]

^ conditional compilation, correspondingly tagged sections are enabled
  via tag_list
  [a,b]         a OR  b
  [a-b]         a AND b
  [a, b-c]      a OR (b AND c)
  [!a]          NOT a
  [{a,b}-c]     (a OR b) AND c
  [!a, b-c]     (NOT a) OR (b AND c)

PUBLIC,PRIVATE,PROTECTED : member-function visibility

EXTENSION class foo {...}
extends the class foo with more members. e.g. splitting a module

IMPLEMENT
member function attribute. Member function is already declared in the
class and do not need to be copied to class again.

explicit, static, virtual
preserved on function members, removed for actual function defs

inline
preserved for func defs, deleted for generated member function decls

inline NEEDS [deps]
specify dependencies for the inline. Those will be exported as well

inline NOEXPORT
do not export even for public function. This ends up in impl file.

inline ALWAYS_INLINE

What I don’t like about it: completely opinionated.

This breaks everything you have configured for your c++ development environment. The elephant in the room is that you are not writing valid C++ syntax. This means your coding tools, LSPs, static checkers etc. would not work. Of course these stuffs were not the case 20 years ago.
I’m not sure if this does you a readability favor, or the other way around.
The interplay of this preprocessor and conditional macros (if you use any) would be nasty.
deprecated by c++20 modules?

§ C++ “conventions”

L4RE CODE READING : IPC, object, task, low-level

i@shrik3.com (SHRIK3) — Mon, 26 May 2025 17:29:11 +0200

This note is taken away from the following sources. Re-distributions MUST preserve the attributions. L4RE documentations:

https://l4re.org/doc/l4re_concepts_ipc.html

From TU Dresden Lecture “Microkernel-based Operating Systems”

“Inter-Process Communication”, Nils Asmussen, TU Dresden, 29.Okt.2024

§ Task and thread ctrl

Class inheritance

 kern/mem_space.cpp    kern/obj_space.cpp               
    + arch extensions     + obj_space-{phys,virt}.cpp   
 ┌────────────────┐    ┌─────────────────┐              
 │ Mem_space      │    │Generic_obj_space│              
 └────────────┬───┘    └┬────────────────┘              
              │         │                               
              │         │                               
        ┌─────▼─────────▼─┐                             
        │ Space           │ +Ref_cnt_obj                
        └────────┬────────┘                             
                 │                                      
        ┌────────▼────────┐                             
        │ Task            │ +Dyn_castable<Task,Kobject> 
        └─┬──────────┬────┘                             
          │          │
 ┌────────▼────┐ ┌───▼─────────┐                        
 │ Kernel_task │ │ Sigma0_task │
 └─────────────┘ └─────────────┘                             


Space : aggregates a set of address spaces
Task  : a protection domain, provides initialization and destruction
        functionality.

§ IPC overview

l4_ipc() : generic l4 object invocation, inlined. Arch specific.

                                                                                 
 call path of L4 (fiasco) ipc.
                                        ARCH DEPENDENT CODE
                                         ┌───────────────┐                       
                                         │ amd64: syscall│ invoke syscall
                                         │ arm64: svc #0 │
                                         └───────────────┘
┌────────────────────────┐  ┌─────────┐  ┌───────────────┐
│l4_ipc_*()  // ipc.h    ├──► l4_ipc()├──► syscall entry │                       
├────────────────────────┤  └─────────┘  └───────┬───────┘
│l4_ipc_call()           │                       │       
│l4_ipc_receive()        │               ┌───────▼───────┐ e.g.                  
│l4_ipc_send()           │               │vector handler │ arm_esr_entry()
│l4_ipc_send_and_wait()  │               └───────┬───────┘  └►handle_svc()
│l4_ipc_wait()           │                       │           └►do_syscall()
│l4_ipc_reply_and_wait() │               ┌───────▼───────┐
└────────────────────────┘               │syscall table  │
                                         └───────┬───────┘                       
                         ┏━━━━━━━━━━━━━━━┓       │
     /kern/syscalls.cpp  ┃sys_ipc_wrapper◄───────┘
                         ┗━━━━━━━━━━━━━━━┛
                           │
                        ┌──▼────────────────────┐
 fetch the obj ref      │ o = obj.deref(&rights)│ kern/thread_object.cpp
 and invoke             └──────┬────────────────┤                       
                           │   │  lookup_local()│ kern/obj_space-
                           │   └────────────────┘        {virt,phys}.cpp
                           │
                        ┏━━▼━━━━━━━━━━━━┓                               
                        ┃ o->invoke()   ┃         kern/ipc_gate.cpp
                        ┗━━━━━━━━━━━━━━━┛         kern/thread_object.cpp
                           │
                        ┏━━▼━━━━━━━━━━━━┓
                        ┃ do_ipc()      ┃         kern/thread-ipc.cpp
                        ┗━━━━━━━━━━━━━━━┛



extern "C" void sys_ipc_wrapper()
{
  assert (!(current()->state() & Thread_drq_ready));

  Thread *curr = current_thread();
  Syscall_frame *f = curr->regs()->syscall_frame();

  // [snap] some assertions (CFG NDEBUG)
  
  // the requested object
  Obj_cap obj = f->ref();
  // set flag?
  Utcb *utcb = curr->utcb().access(true);
  // model based testing
  curr->increment_mbt_counter();

  L4_fpage::Rights rights;
  // deref object and get caller rights
  Kobject_iface *o = obj.deref(&rights);        // lockup_local(cap(), rights)
  if (EXPECT_TRUE(o!=nullptr))
    o->invoke(obj, rights, f, utcb);
  else
    f->tag(curr->commit_error(utcb, L4_error::Not_existent));
}

§ OBJECT

each l4re task is assgined a factory object. factory object creates other objects.

§ OBJECT SPACE MANAGEMENT

§ IPC Gate

IPC GATE OBJECT (IMCOMPLETE)

class Ipc_gate : Kobject {
    friend class Ipc_gate_ctl;
    friend class Jdb_sender_list;
protected:
    Thread *_thread;
    Mword _id;
    Ram_quota *_quota;
    Locked_prio_list _wait_q;
}

§ FLESPAGE

flexpage represents a naturally aligned area of mappable space. Is used to describe resources in the sender’s address space.

map & unmap

L4RE hands-on : adding a package / service (WIP)

i@shrik3.com (SHRIK3) — Fri, 23 May 2025 14:51:38 +0200

L4RE hands-on : hello world and boot ISO

i@shrik3.com (SHRIK3) — Mon, 19 May 2025 19:44:42 +0200

REFS

https://l4re.org/getting_started/make.html (CC-BY-SA 4.0, L4Re project members and individual contributors)

Basically a plaintext note for my own reference.

DEPS AND ENV

pacman:
    base-devel dtc lib32-gcc-libs qemu qemu-ar
aur:
    perl-git-repository perl-xml-mini perl-uri
ham (include in $PATH)
    https://github.com/kernkonzept/ham.git

prepare the sources with ham

mkdir $PROJ_BASE
cd $PROJ_BASE
ham init -u https://github.com/kernkonzept/manifest.git
ham sync

dir naming convention (x86_64)

PROJ_BASE=/PATH/TO/PROJ/ROOT
export L4RE_SRCDIR      ="${PROJ_BASE}/l4"
export L4RE_OBJDIR      ="${PROJ_BASE}/l4re_builds/x86_64"
export KERNEL_SRCDIR    ="${PROJ_BASE}/fiasco"
export KERNEL_OBJDIR    ="${PROJ_BASE}/fiasco_builds/x86_64"

STRUCT
.
├── .ham            # managed by ham tool
├── fiasco          # the L4RE microkernel (namely the "kernel")
├── l4              # the L4RE (OS framework)
├── fiasco_builds   # kernel build dir : initialized later
└── l4re_builds     # L4RE build dir   : initialized later

BUILDING L4

If you build L4RE from source (instead of using a snapshot), you are default to the amd64 build. To change the default target modify the Maiefile:

diff --git a/Makefile b/Makefile
index 49cca2f..a9b7037 100644
--- a/Makefile
+++ b/Makefile
@@ -52,7 +52,7 @@ all::

 DROPSCONF               = y
 TEMPLDIR              := mk/defconfig
-DFL_TEMPLATE           := amd64
+DFL_TEMPLATE           := x8

BUILDING L4RE

# initialize L4 build dir, only do once
$ cd $L4RE_SRCDIR       # l4
$ make B=$L4RE_OBJDIR   # l4re_builds/x86_64

# build L4RE from src tree
cd $L4RE_SRCDIR         # l4
make O=$L4RE_OBJDIR     # l4re_builds/x86_64

# or in the build tree
cd $L4RE_OBJDIR         # l4re_builds/x86_64
make

# (optional) to change the configs
cd $L4RE_OBJDIR         # l4re_builds/x86_64
make config

# (amd64) build target in
# $L4RE_OBJDIR/bin/amd64_gen/l4f/

BUILDING L4 MICROKERNEL (FIASCO)

cd $KERNEL_SRCDIR       # fiasco
make B=$KERNEL_OBJDIR   # fiasco_builds/x86_64
cd $KERNEL_OBJDIR       # fiasco_builds/x86_64
make

HELLOWORLD

cd $L4RE_OBJDIR
make E=hello-cfg qemu MODULE_SEARCH_PATH=$KERNEL_OBJDIR:$L4RE_SRCDIR/conf/examples

USING THE SNAPSHOT

DOWNLOAD FROM: https://os.inf.tu-dresden.de/download/snapshots/ and .. read instructions there, maybe.

# cd snapshot
make setup
make

BUILDING L4 BOOTABLE ISO

box drawing characters

i@shrik3.com (SHRIK3) — Sun, 18 May 2025 20:09:12 +0200

UNICODE “BOX DRAWING” BLOCK (ALSO IN IBM PC CHARSET). THE MOSTLY SUPPORTED SET

        0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
U+250x  ─  ━  │  ┃  ┄  ┅  ┆  ┇  ┈  ┉  ┊  ┋  ┌  ┍  ┎  ┏

U+251x  ┐  ┑  ┒  ┓  └  ┕  ┖  ┗  ┘  ┙  ┚  ┛  ├  ┝  ┞  ┟

U+252x  ┠  ┡  ┢  ┣  ┤  ┥  ┦  ┧  ┨  ┩  ┪  ┫  ┬  ┭  ┮  ┯

U+253x  ┰  ┱  ┲  ┳  ┴  ┵  ┶  ┷  ┸  ┹  ┺  ┻  ┼  ┽  ┾  ┿

U+254x  ╀  ╁  ╂  ╃  ╄  ╅  ╆  ╇  ╈  ╉  ╊  ╋  ╌  ╍  ╎  ╏

U+255x  ═  ║  ╒  ╓  ╔  ╕  ╖  ╗  ╘  ╙  ╚  ╛  ╜  ╝  ╞  ╟

U+256x  ╠  ╡  ╢  ╣  ╤  ╥  ╦  ╧  ╨  ╩  ╪  ╫  ╬  ╭  ╮  ╯

U+257x  ╰  ╱  ╲  ╳  ╴  ╵  ╶  ╷  ╸  ╹  ╺  ╻  ╼  ╽  ╾  ╿ 

U+258x  ▀  ▁  ▂  ▃  ▄  ▅  ▆  ▇  █  ▉  ▊  ▋  ▌  ▍  ▎  ▏

U+259x  ▐  ░  ▒  ▓  ▔  ▕  ▖  ▗  ▘  ▙  ▚  ▛  ▜  ▝  ▞  ▟

13.0 EXTENSION (LESS SUPPORTED IN FONTS), NOT NECESSARILY MONOSPACE

          0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
U+1FB0x   🬀  🬁  🬂  🬃  🬄  🬅  🬆  🬇  🬈  🬉  🬊  🬋  🬌  🬍  🬎  🬏
U+1FB1x   🬐  🬑  🬒  🬓  🬔  🬕  🬖  🬗  🬘  🬙  🬚  🬛  🬜  🬝  🬞  🬟
U+1FB2x   🬠  🬡  🬢  🬣  🬤  🬥  🬦  🬧  🬨  🬩  🬪  🬫  🬬  🬭  🬮  🬯
U+1FB3x   🬰  🬱  🬲  🬳  🬴  🬵  🬶  🬷  🬸  🬹  🬺  🬻  🬼  🬽  🬾  🬿
U+1FB4x   🭀  🭁  🭂  🭃  🭄  🭅  🭆  🭇  🭈  🭉  🭊  🭋  🭌  🭍  🭎  🭏
U+1FB5x   🭐  🭑  🭒  🭓  🭔  🭕  🭖  🭗  🭘  🭙  🭚  🭛  🭜  🭝  🭞  🭟
U+1FB6x   🭠  🭡  🭢  🭣  🭤  🭥  🭦  🭧  🭨  🭩  🭪  🭫  🭬  🭭  🭮  🭯
U+1FB7x   🭰  🭱  🭲  🭳  🭴  🭵  🭶  🭷  🭸  🭹  🭺  🭻  🭼  🭽  🭾  🭿
U+1FB8x   🮀  🮁  🮂  🮃  🮄  🮅  🮆  🮇  🮈  🮉  🮊  🮋  🮌  🮍  🮎  🮏
U+1FB9x   🮐  🮑  🮒     🮔  🮕  🮖  🮗  🮘  🮙  🮚  🮛  🮜  🮝  🮞  🮟
U+1FBAx   🮠  🮡  🮢  🮣  🮤  🮥  🮦  🮧  🮨  🮩  🮪  🮫  🮬  🮭  🮮  🮯
U+1FBBx   🮰  🮱  🮲  🮳  🮴  🮵  🮶  🮷  🮸  🮹  🮺  🮻  🮼  🮽  🮾  🮿
U+1FBCx   🯀  🯁  🯂  🯃  🯄  🯅  🯆  🯇  🯈  🯉  🯊  🯋  🯌  🯍  🯎  🯏
U+1FBDx   🯐  🯑  🯒  🯓  🯔  🯕  🯖  🯗  🯘  🯙  🯚  🯛  🯜  🯝  🯞  🯟
U+1FBEx   🯠  🯡  🯢  🯣  🯤  🯥  🯦  🯧  🯨  🯩  🯪  🯫  🯬  🯭  🯮  🯯
U+1FBFx   🯰  🯱  🯲  🯳  🯴  🯵  🯶  🯷  🯸  🯹

If the system has imcompatible font, the box drawing chars may fail to be monospaced. E.g. the two bars below should be of equal length, but that may not be the case on some devices (like my android firefox)

──────────
----------

Also some chars can’t be monospaced at all… because they are pretty wide..

-----
-.-.-
⨁-----
mm----
测试一二三
12345678

https://en.wikipedia.org/wiki/Box-drawing_characters

L/R values, reference, copy and move semantics

i@shrik3.com (SHRIK3) — Fri, 16 May 2025 15:42:22 +0200

C++STD:

SF ANSWER

https://stackoverflow.com/questions/3601602/what-are-rvalues-lvalues-xvalues-glvalues-and-prvalues

BLOGS TO READ

I find it extremely painful to understand all those l,r,gl,x,pr values before going through the move semantics.

CONSTRUCTORS

C++ constructors DOES NOT RETURN ANYTHING (not even void)
constructor is a special method that is automatically called when an object is created.

it’s illegal to have “uninitialized object”.

class A {/**/};
// illegal: can't find (or derive) constructor that takes no param
A arr[100];

THE MOVE AND COPY SEMANTICS

CODE EXAMPLE ALL IN ONE NOTE: DERIVED FROM THIS ARTICLE BY TRIANGLES

#include <algorithm>
#include <cstddef>
#include <iostream>

using namespace std;
class Holder {
private:
  int *m_data;
  size_t m_size;

public:
  // constructor
  Holder(int size) {
    m_data = new int[size];
    m_size = size;
  }

  // destructor
  ~Holder() {
    delete[] m_data;
  }

  // copy constructor: initialize [this] from already-existing object
  // (other is read-only reference)
  Holder(const Holder &other) {
    m_data = new int[other.m_size];
    std::copy(other.m_data, other.m_data + other.m_size, m_data);
    m_size = other.m_size;
  }

  // copy assignment constructor: nuke [this] and re-initizlize from
  // already-existing object
  Holder &operator=(const Holder &other) {
    if (this == &other) {
      return *this;
    }
    // first nuke existing data
    delete[] m_data;
    // same as copy constructor
    m_data = new int[other.m_size];
    std::copy(other.m_data, other.m_data + other.m_size, m_data);
    m_size = other.m_size;
    return *this;
  }

  // move constructor : reuse resource from other, no need to copy
  Holder(Holder &&other) {
    m_data = other.m_data;
    m_size = other.m_size;
    // prevent the data from being freed when other goes out of scope
    other.m_data = nullptr;
    other.m_size = 0;
  }

  // move assignment operator
  Holder &operator=(Holder &&other) {
    // same as first step of assignment oplerator
    if (this == &other)
      return *this;
    delete[] m_data;
    // same as copy constructor
    m_data = other.m_data;
    m_size = other.m_size;
    other.m_data = nullptr;
    other.m_size = 0;
    return *this;
  }
};

// if you simply return Holder h(size) the compiler may inline this function
// even with -fno-elide-constructors
Holder createHolder(size_t size) {
  Holder h(size);
  return h;
}

int main() {
  // default constructor
  Holder h0(0x1);
  Holder g1(0x2);
  Holder g2(0x2);
  Holder g3(0x2);

  // copy constructor:
  // h0 is a lvalue, therefore it's not safe to move
  Holder h1(h0);

  // default constructor in createHolder() to create the temporary RVALUE
  // then move constructor to create h2;
  // when move-constructor is not defined, this falls back to copy;
  // finally destructor on the temporary value (out-of-scope).
  Holder h2(createHolder(0x2));

  // copy assignment because h1 is LVALUE thus unsafe to move
  g1 = h1;

  // move assignment because functurn returns RVALUE (safe to move)
  // however with -fno-elide-copy there is an extra move-constructor
  // in-between. WHY?
  g2 = createHolder(500);

  // move assignment with lvalue because we explicitly do so.
  // std::move() also falls back to copy if move methods are not present
  g3 = std::move(h1);       // move assignment with lvalue
  Holder g4(std::move(g3)); // move constructor with lvalue

  return 0;
}

C++ gvalue, prvalue, xvalue, lvalue, rvalue (fuck me, fuck you all)


 GLVALUE       
                     "Classical" notations of LVALUE (IN C)
┌────────────┐       cannot be function calls.
│ LVALUE     │       C++ extends it to include function calls
│            │
│            │       Historically: expressions legal on
│            │       the LHS of "=" are LVALUE
│   ┌────────┼───┐
│   │ XVALUE │   │   "Classical" notations of LVALUES
└───┼────────┘   │   are automatically legal on the RHS
    │            │
    │            │
    │            │
    │    PRVALUE │   Hence the "pure" RVALUE
    └────────────┘

                 RVALUE

N3092 Ch.3.10 : you should not dig into these definitions because they suck, this is nothing near formalization

An LVALUE could appear on the LHS of an assignment expression. It desinates an object or a function call (the return type in should be a lvalue reference)
An XVALUE (eXpiring value) also refers to an object, usually near the end of its lifetime (fuck this definition.)
A GLVALUE is an lvalue or an xvalue (fuck this definition, too)
An RVALUE (so called, historically, because rvalues could appear on the right-hand side of an assignment expressions) is an xvalue, a temporary object (12.2) or subobject thereof, or a value that is not associated with an object.
A PRVALUE (“pure” rvalue) is an rvalue that is not an xvalue.

Classical “L VALUE” (in C): a place in the memory that can hold a value. A variable, a pointer dereference expression using *, structure field reference using . or ->, array-element reference using [] (if the array is an lvalue). etc.
ISO 2011 C STD: An lvalue is an expression (with an object type other than void) that potentially designates an object; if an lvalue does not designate an object when it is evaluated, the behavior is undefined.

notes on L-VALUE (C)

C STD doesn’t specify exactly the R-VALUE
an array (without []) identifies memory location but is not L-VALUE
L VALUE doesn’t have to be mutable (e.g. const)
function pointer and function calls (regardless of return) are not L-VALUE
all L-VALUE are valid as R-VALUE (in the sense of valid on the right of assignments) but not vice versa.

C++ std string and string_view

i@shrik3.com (SHRIK3) — Fri, 16 May 2025 15:35:28 +0200

https://www.learncpp.com/cpp-tutorial/introduction-to-stdstring/

std::string

can have flexible length, involves malloc, slower
passing std::string by value causes a copy, so don’t
- use std::string_view or const std::string& as parameter
supports move semantics, return std::string by value is fine
doesn’t work well with constexpr (use string_view) instead

#include <iostream>
#include <string>

int main()
{
    std::string name { "Alex" }; // initialize name with string literal "Alex"
    name = "Jason";              // change name to a longer string
    name = "Jay";                // change name to a shorter string
    size_t l = name.length();       // get length
    return 0;
}

string literal


int main()
{
    using namespace std::string_literals;      // access the s suffix
    using namespace std::string_view_literals; // access the sv suffix

    std::cout << "foo";   // null terminated c style string literal
    std::cout << "bar"s;  // std::string literal (with the suffix 's')
    std::cout << "zaa"sv; // std::string_view literal (with the suffix 'sv')
    // std::string literal is equivalant to
    auto s = std::string {"bar", 3} ;
    return 0;
}

std::string_view (c++17)

basically the rust slice
provides read-only access to existing string (or another string_view)
no copy
string_view parameter can take a std::string (implicit conversion), no copy
do not return a string_view if created from a local string
not vice versa: std::string_view doesn’t implicitly convert to std::string
can create a std::string with a std::string_view initializer or static_cast a string_view to string
fully supports constexpr
prefer to use constexpr std::string_view for string symbolic constants

#include <iostream>
#include <string>
#include <string_view>

int main()
{
    // initialize with C-style string literal
    std::string_view s1 { "Hello, world!" };

    // initialize with std::string
    std::string s{ "Hello, world!" };
    std::string_view s2 { s };

    // initialize with std::string_view
    std::string_view s3 { s2 };

    return 0;
}

string_view lifetime

#include <iostream>
#include <string>
#include <string_view>

int main()
{
    std::string_view sv{};

    {
        std::string s{ "Hello, world!" };
        sv = s; // sv is now viewing s
    } // s is destroyed here, so sv is now viewing an invalid string

    std::cout << sv << '\n'; // undefined behavior

    return 0;
}

int main2()
{
    std::string s { "Hello, world!" };
    // sv views s
    std::string_view sv { s };

    // modifies s, which invalidates sv (s is still valid)
    s = "Hello, universe!";
    // Viewing through sv is UB here

    // revalidate sv
    sv = s;
    // viewing through sv is valid here.

    return 0;
}

do not initialize std::string_view from std::string literal => dangling string_view

C++ std::thread (std <= 17)

i@shrik3.com (SHRIK3) — Fri, 16 May 2025 15:28:23 +0200

Constructors

thread() noexcept;
thread( thead && other ) noexcept;

C++ lambda

i@shrik3.com (SHRIK3) — Wed, 14 May 2025 14:44:30 +0200

MAIN REFERENCE: Modern C++ Features (Anthony Calandra), overview C++20/17/14/11 (MIT)

QUICK NTOES

c++ 11 (introduced)

[<CAPTURE>] (<params>) -> <return type> {/* BODY */}
[] no capture
[=] and [&] : capture local objects in scope by value or reference. Can specify objects by name e.g. [a, &b]
[this] : capture this by reference

c++ 14

generic lambda expressions (auto initializer)

auto identity = [](auto x) { return x; };
int three = identity(3);        // 3
string foo = identity("foo"):   // "foo"

labda capture initializers. The capture introduces new name inside the lambda body. The expression is evaluated when lambda is created (not when its invoked)>

int factory(int i) {return i * 10; }
auto f = [x = factory(2)] {return x;}   // x is a new name, not a local obj

// x = 0 is evaluated ONCE at creation. Analoge static variable in
// function
auto generator = [x = 0] () mutable { return x++; };
auto a = generator();   // 0
auto b = generator();   // 1
auto c = generator();   // 2

c++ 17

constexpr lambda compile time lambdas using constexpr.

auto identity = [](int n) constexpr { return n; };
static_assert(identity(123) == 123);

constexpr auto add = [](int x, int y) {
  auto L = [=] { return x; };
  auto R = [=] { return y; };
  return [=] { return L() + R(); };
};

static_assert(add(1, 2)() == 3);

constexpr int addOne(int n) {
  return [n] { return n + 1; }();
}

static_assert(addOne(1) == 2)

lambda capture this by value. *this (C++17) will now make a copy of the current object, while this (C++11) continues to capture by reference.

c++ 20

template syntax for lambda

auto f = []<typename T>(std::vector<T> v) {
  // ...
};

lambda capture of parameter pack

template <typename... Args>
auto f(Args&&... args){
    // BY VALUE:
    return [...args = std::forward<Args>(args)] {};
    // BY REFERENCE
    return [&...args = std::forward<Args>(args)] {
}

Deprecate implicit capture of this: Implicitly capturing this in a lambda capture using [=] is now deprecated; prefer capturing explicitly using [=,this] or [=, *this].

ALL IN ONE EXAMPLE

#include <iostream>
int main() {
  int x = 1;
  auto getX = [=](void) -> int { return x; };
  // same as  [=] {return x;};
  // illegal: [=] -> int {return x;};
  auto errX = [=](void) mutable -> int { x += 1; return x; };
  // without `mutable` it's not allowed to modify x value (even it has no effect
  // on the original x.
  auto addX = [=](int y) { return x + y; };
  // do not need mutable to modify via reference.
  auto incX = [&](int y) { x += y; };
  auto refX = [&]() -> int & { return x; };

  std::cout << getX() << std::endl;  // 1
  std::cout << addX(1) << std::endl; // 2
  errX();
  std::cout << x << std::endl;       // 1

  incX(100);
  std::cout << getX() << std::endl; // 1 because value captured before inc
  std::cout << x << std::endl;      // 101 x is modified via reference

  auto& refx = refX();              // & is important, otherwise auto deduces
                                    // the reference into int and performs copy
  refx += 42;
  std::cout << getX() << std::endl; // 1 (old captured value)
  std::cout << x << std::endl;      // 101 (why????)

  return 0;
}

spinlock impl

i@shrik3.com (SHRIK3) — Tue, 13 May 2025 11:48:17 +0200

COPYRIGHT NOTICE: text and code copied or derived from git commit message, mailinglist, or codebase are subject to the linux kernel licensing rules

documentations:
Lock types and their rules
https://docs.kernel.org/locking/locktypes.html

Synchronization primitives in the Linux kernel. (from the Linux Inside blog series) https://0xax.gitbooks.io/linux-insides/content/SyncPrim/

MCS locks and qspinlocks
https://lwn.net/Articles/590243/

SEMANTICS:

spinlocks are

raw_spinlock_t (ALL)
bit spinlocks (ALL)
spinlock_t (NON-PREEMPT)
rwlock_t (NON-PREEMPT)

on PREEMPT_RT kernels: {spinlock_t, rwlock_t, local_lock} are converted to sleeping locks

Well, on PREEMPT_RT kernels the spinlock_t is actually not a spinning lock.

spinlock apis

spin_lock_init
suffix bh : disables software interrupts (bottomhalves)
suffix irq / irqsave: disable interrupts on local processors, do or do not preserve the interrupt state in the flags (restore via _irqrestore)
spin_lock and spin_unlock: acquire and release the lock

raw_spinlock_t

raw_spinlock_t is strict spinning lock for all kernels. On NON-PREEMPT kernels spinlock_t and raw_spinlock_t have same semantics.

preemption or interrupts must be disabled for spinning lock critical sections, because (if) the spinning wait cannot be preempted.

consider the following threads

// THREAD 1
spin_lock(l);
// critical section <- PREEMPTED
spin_unlock(l);

// THREAD 2
spin_lock(l);    // spinning forever
spin_unlock(l);

The hard irq handler MUST NOT block. Below is a deadlock even with one single thread.

// KERNEL CODE
spin_lock(l);
// interrupted here ------>
read_and_work(buf);
spin_unlock(l);



// INTERRUPT HANDLER
spin_lock(l);   // spins forever
spin_unlock(l);

linux code:

raw_spinlock_t is defined in spinlock_types_raw.h
the underlying arch_spinlock_t could be implemented as either queued spinlock; ticket lock arm or a primitive int.

queued spinlock


/*
 * By using the whole 2nd least significant byte for the
 * pending bit, we can allow better optimization of the lock
 * acquisition for the pending bit holder.
 */

typedef struct qspinlock {
    union {
        atomic_t val;
        struct {
            u8  locked;
            u8  pending;
        };
        struct {
            u16 locked_pending;
            u16 tail;
        };
    };
} arch_spinlock_t;

SOURCE CODE FILES

include/linux/spinlock.h: generic spinlock/rwlock declarations

here’s the role of the various spinlock/rwlock related include files:

on SMP builds:

asm/spinlock_types.h: contains the arch_spinlock_t/arch_rwlock_t and the initializers
linux/spinlock_types_raw: The raw types and initializers
linux/spinlock_types.h: defines the generic type and initializers
asm/spinlock.h: contains the arch_spin_*()/etc. lowlevel implementations, mostly inline assembly code

(also included on UP-debug builds:)

linux/spinlock_api_smp.h: contains the prototypes for the spin*() APIs.
linux/spinlock.h: builds the final spin_*() APIs.

on UP builds:

linux/spinlock_type_up.h: contains the generic, simplified UP spinlock type. (which is an empty structure on non-debug builds)
linux/spinlock_types_raw: The raw RT types and initializers linux/spinlock_types.h:; defines the generic type and initializers linux/spinlock_up.h:; contains the arch_spin_*()/etc. version of UP builds. (which are NOPs on non-debug, non-preempt builds)

(included on UP-non-debug builds:)

linux/spinlock_api_up.h: builds the spin*() APIs.
linux/spinlock.h: builds the final spin_*() APIs.

CONFIG_DEBUG_SPINLOCK

i@shrik3.com (SHRIK3) — Tue, 13 May 2025 11:09:29 +0200

bject to the [linux kernel licensing rules](https://www.kernel.org/doc/html/latest/process/license-rules.html)

config flag helper text: Say Y here and build SMP to catch missing spinlock initialization and certain other kinds of spinlock errors commonly made. This is best used in conjunction with the NMI watchdog so that spinlock deadlocks are also debuggable.

lockdep

i@shrik3.com (SHRIK3) — Tue, 13 May 2025 11:09:00 +0200

COPYRIGHT NOTICE: text and code copied or derived from git commit message, mailinglist, or codebase are subject to the linux kernel licensing rules

R/W lock impl

i@shrik3.com (SHRIK3) — Tue, 13 May 2025 11:07:32 +0200

COPYRIGHT NOTICE: text and code copied or derived from git commit message, mailinglist, or codebase are subject to the linux kernel licensing rules

documentations:
Lock types and their rules
https://docs.kernel.org/locking/locktypes.html

NOTE: this is based on the code reading for spinlocks

rwlock_t

Non-PREEMPT_RT kernels: impl rwlock_t as spinning lock and the suffix rules of spinlock_t apply accordingly. This implementation is fair, no writer starvation.

PREMMPT_RT kernels: map rwlock_t to a rt_mutex based impl.

all spinlock_t changes also apply to rwlock_t
writer cannot grant its priority to multiple readers. a preempted low-priority reader will continue holding the lock, thus starving even high-priority writers. In contrast, because readers can grant their priority to a writer, a preempted low-priority writer will have its priority boosted until it releases the lock, thus preventing that writer from starving the readers.

NON PREEMPT_RT (spinlock based)

typedef struct {
    arch_rwlock_t   raw_lock;
} rwlock_t;

// x86
// arch/x86/include/asm/spinlock_types.h
//  -> include/asm-generic/qrwlock_types.h

the qrwlock is fair, queued rwlock, introduced @ 70af2f8a: the rwlock uses the arch_spinlock_t as a waitqueue and assuming the arch_spin_lock_t is a fair lock (ticket, mcs etc..), the resulting rwlock is a fair lock.

/*
 * The queued read/write lock data structure
 */

typedef struct qrwlock {
    union {
        atomic_t cnts;
        struct {        /* for big endian the fields order is swapped*/
            u8 wlocked; /* Locked for write? */
            u8 __lstate[3];
        };
    };
    arch_spinlock_t     wait_lock;
} arch_rwlock_t;

#define __ARCH_RW_LOCK_UNLOCKED {       \
    { .cnts = ATOMIC_INIT(0), },        \
    .wait_lock = __ARCH_SPIN_LOCK_UNLOCKED, \
}

PREEMPT_RT (rt_mutex based)

// include/linux/rwbase_rt.h
struct rwbase_rt {
    atomic_t                readers;
    struct rt_mutex_base    rtmutex;
};

// include/linux/rwlock_types.h
typedef struct {
    struct rwbase_rt    rwbase;
    atomic_t            readers;
} rwlock_t;

Reader/Writer Locks

i@shrik3.com (SHRIK3) — Mon, 12 May 2025 18:41:13 +0200

Literature study and example implementations for Reader/Writer Locks

Main reference (actually this one is a takeaway from)
B. Reddy and R. Fields, “Techniques for Reader-Writer Lock Synchronization,” IJEEE, vol. 8, no. 4, pp. 63–73, Dec. 2020, doi: 10.18178/ijeee.8.4.63-73.¹

A second thought: this paper doesn’t seem carefully written… There are many typos and inconsistencies. So I’ll just use this as a primer and do literature research myself.

§ Taxonomy

Centralized Reader-Writer locks

Preference Reader-Writer Lock: prioritize reader or writer, either unpreferred could starve. Allows for fairness within the preferred side.
Phase-fair Reader-Writer lock (improv of preference lock)
Task-Fair Reader-Writer Lock: readers and writers are given the same priority. Access to critical section is FIFO.
[?] what does FIFO mean when concurrent readers are allowed?
Worst case: interleaving reader and writer would behave like mutual exclusion instead of Reader/Writer lock
rw locks with exponential back off
- fair improvement w/ ticket lock

Queue based Reader-Writer locks

MCS spin based Reader-Writer locks
Kreiger et al. MCS improvement
Hsieh and Weihl improvement
CLH lock
blased locking

NUMA aware rw locks (such are also either centralized or queue-based)

Hierarchical Backoff Lock (HBO)
HCLH (hierarchical CLH)
lock cohorting
augmented general locks

§ impl.

Baseline R/W Lock

R/W Lock in linux kernel

B. Reddy and R. Fields, “Techniques for Reader-Writer Lock Synchronization,” IJEEE, vol. 8, no. 4, pp. 63–73, Dec. 2020, doi:10.18178/ijeee.8.4.63-73.
https://www.ijeee.net/uploadfile/2020/1214/20201214104118234.pdf ↩︎

C with class

i@shrik3.com (SHRIK3) — Mon, 12 May 2025 11:02:34 +0200

linux futex (fast user-space locking)

i@shrik3.com (SHRIK3) — Sun, 11 May 2025 19:22:56 +0200

§ RTFM : manpage for futex(2)

NAME
       futex - fast user-space locking

LIBRARY
       Standard C library (libc, -lc)

SYNOPSIS
       #include <linux/futex.h>      /* Definition of FUTEX_* constants */
       #include <sys/syscall.h>      /* Definition of SYS_* constants */
       #include <unistd.h>

       long syscall(SYS_futex,
                    uint32_t *uaddr,    // points to futex word
                    int futex_op,
                    uint32_t val,
                    const struct timespec *timeout,   /* or: uint32_t val2 */
                    uint32_t *uaddr2,
                    uint32_t val3);

Note: glibc provides no wrapper for futex(), necessitating the use of syscall

futex is always 32bit value (refered to by *uaddr) and must be 4-byte aligned.
futex syscall takes process userspace virt addr, but it’s internally handled by the kernel via physical address (thus allowing sharing among different processes

FUTEX_OP FLAGS

FUTEX_PRIVATE_FLAG (can be used for all)
    the futex is process-private and is not shared with another process. For
    convenience some futex_op flags can have _PRIVATE suffix e.g.
    FUTEX_WAIT_PRIVATE == FUTEX_WAIT_PRIVATE | FUTEX_PRIVATE_FLAG

FUTEX_CLOCK_REALTIME (check manual for applied futex_ops)
    either the timeout is measure against the CLOCK_REALTIME clock or
    (default / unset) CLOCK_MONOTONIC clock

FUTEX_WAIT and FUTEX_WAKE

PARAS
    uaddr       : points to the futex (for all futex_op)

FUTEX_WAIT
    val         : expected value of the futex (as poitned by uaddr)
    timeout     : (relative) timeout for the sleep; if NULL the call blocks
                  indefinitely until waken
    uaddr2/val3 : ignored

FUTEX_WAKE
    val         : max number of waiters to wake up (INT_MAX to wake all)
    timeout     : ignored
    uaddr2/val3 : ignored

if expected val doesn’t match actual value (via a atomic load in the kernel) the call will return immediately with EAGAIN (was EDOUBLELOCK in earlier versions)

FUTEX_WAKE_OP

PARAS - WAKE_OP

    timeout     : used as val2, (max waiters to wake for futex2)
    uaddr2      : points to the second futex

    val3        : compond value as folows
    +---+---+-----------+-----------+
    |op |cmp|   oparg   |  cmparg   |
    +---+---+-----------+-----------+
    4   4       12          12    <== # of bits

is equivalent to executing the following code atomically and totally ordered wrt. other futex operations on any of the the two supplied futex words

uint32_t oldval = *(uint32_t *) uaddr2;
*(uint32_t *) uaddr2 = oldval op oparg;
futex(uaddr, FUTEX_WAKE, val, 0, 0, 0);
if (oldval cmp cmparg)
    futex(uaddr2, FUTEX_WAKE, val2, 0, 0, 0);

saves the old futex2 value (pointed by uaddr2) and performs an operation to modity the value of futex2 (via a Read-Modify-Write atomic memory op).
wakes up max val waiter on futex1 (*uaddr) like FUTEX_WAKE
dependent on the results of a test of the old value of futex2, wakes up max val2 waiters

FUTEX_WAIT_BITSET and FUTEX_WAKE_BITSET (TODO)

§ userspace lock implementations with futex

share futex between processes via manual mmap(). Code from here

iaddr = mmap(NULL,              /* no addr specs for the allocation */
    sizeof(int) * 2,            /* mapping for 2 futexes */
    PROT_READ | PROT_WRITE,     /* allow read write access */
    MAP_ANONYMOUS | MAP_SHARED, /* anonymous mapping + shared */
    -1, 0                       /* fd = -1 for anon mapping, no offset */
    )

futex1 = &iaddr[0];
futex2 = &iaddr[1];

pid = fork();                   /* child inherits the shared anon mapping */

if (pid == -1) {/* fork error */}
if (cpid == 0) {/* child */ } else {/* parent */}

CODE EXAMPLES

impl MUTEX via FUTEX

Ulricht ¹ lists in their paper a few mutex implementations via futex, which seem intuitive but turn out to be incorrect. Here are some recaps, refer to the paper for details

Mutex, Take 1 from ¹

class mutex {
private:
    int val;
public:
    mutex () : val (0) { }
    void lock () {
        int c;
        while ((c =atomic_inc (val)) != 0)
            futex_wait (&val, c + 1);
    }
    void unlock () {
        val = 0;
        futex_wake (&val, 1);
    }
};

pitfalls:

livelock : two lock() calls repeatedly cause each other to fail. Since the val doesn’t match the old value before the sleep, futex_wait call returns immediately with EAGAIN

AC: atomic_inc
FW: futex_wait 

             AC      FW          AC                 FW
thread 1: ---XX------XX-[EAGAIN]-XX-----------------XX-[EAGAIN]-
thread 2: ------XX------------------XX-[EAGAIN]--XX-------------
                AC                  FW           AC

int wraparound on futex val (since waiters unconditionally increment it)
unlock() unnecessarily calls futex_wake() even when uncontested

Mutex, Take 3 from ¹ (same as take 2 but optimized by replacing some cmpxchg with less expensive xchg)

#define UNLOCKED    0
#define NO_WATER    1
#define HAS_WATER   2

static int val = UNLOCKED;

static void lock () {
    int c;
    if ((c = cmpxchg (val, UNLOCKED, NO_WAITER)) != UNLOCKED) {
        // lock is contested
        if (c != HAS_WAITER)              /* the first waiter */
            c = xchg (val, HAS_WAITER);
        while (c != UNLOCKED) {
            futex_wait (&val, HAS_WAITER);
            c = xchg (val, HAS_WAITER);   /* even the last waiter */
        }
    }
    // else: sucessfully taken the lock while there is no waiter
}

static void unlock () {
    if (atomic_dec (val) != NO_WAITER) {
        val = UNLOCKED;
        // <<-- another thread could cut in here
        futex_wake (&val, NO_WAITER);
    }
    // else: take the shortpath, save one syscall
    // in either case val is reset to UNLOCKED
}

NOTE:

the unlock shortpath is taken, if the lock was acquired at the first attempt (line 9)
the UNLOCKED state doesn’t not imply whether there is a waiter. A new thread could cut in @ line 24, sees the UNLOCKED state, takes the lock and sets val to NO_WAITER. The new thread would take the short path for unlock. But the (presumably interrupted) futex_wake() @ line 25 would get called when it resumes, waking a waiting thread. Thus no starvation.
there is no waiter counter, therefore when a waiter is waken, given the lock and finishes the CS, it cannot know whether there are still other waiters.
also, no need to wake more than one thread for a mutex.

§ TODOs

Priority-inheritance futex (TODO)

Futexes Are Tricky, Ulrich Drepper, https://dept-info.labri.fr/~denis/Enseignement/2008-IR/Articles/01-futex.pdf ↩︎ ↩︎ ↩︎

ia32 instructions and micro-arch for locks

i@shrik3.com (SHRIK3) — Sat, 10 May 2025 21:15:18 +0200

back to index

PAUSE instruction: Spin Loop Hint, give hint to processor that improves performance of spin-wait loops. Specifically, to transfer yield CPU to another hyperthread.; The PAUSE instruction provides a hint to the processor that the code sequence is a spin-wait loop. The processor uses this hint to avoid the memory order violation in most situations, which greatly improves processor performance.; An additional function of the PAUSE instruction is to reduce the power consumed by a processor while executing a spin loop. A processor can execute a spin-wait loop extremely quickly, causing the processor to consume a lot of power while it waits for the resource it is spinning on to become available. Inserting a pause instruction in a spin-wait loop greatly reduces the processor’s power consumption.

GCC _mm_pause() expands to __builtin_ia32_pause() then the PAUSE instruction.

This can be used to improve the spinlock performance (instead of a NOP in the busy loop).

while (__stomic_sub_fetch(&lock, 1, __ATOMIC_ACQUIRE) < 0) {
    do
        _mm_pause();
    while (__atomic_load_n(&lock, __ATOMIC_ACQUIRE) != 1);
}

Machine Check Handling (AMD64)

i@shrik3.com (SHRIK3) — Sat, 10 May 2025 17:52:44 +0200

This is meant to be a supplement to

Machine check handling on Linux by Andi Kleen.

References:

https://www.halobates.de/

This page is under CC-BY-SA-4.0, code snippets from the Linux project(s) are under GPL-2.0-only. The above note must be preserved.

Takeaways from Andi Kleen paper

Two types machine check

machine check exceptions (MCEs) / uncorrectable error. It will cause interrupt w/ a special excaption handler.

some atomic memory operations

i@shrik3.com (SHRIK3) — Thu, 08 May 2025 23:16:38 +0200

CMPXCHG - Comapre and Exchange

    [lock] cmpxchg  reg, reg/mem
    ^               ^       ^
    |               |       |
    prefix          SRC     DEST

if al == dest:
    ZF      <- 1
    DEST    <- SRC
else:
    ZF      <- 0
    AX      <- DEST

e.g.
            mov         $0,     %al
    lock    cmpxchg     %edx,   some_lock

linux kernel synchronization (WIP)

i@shrik3.com (SHRIK3) — Thu, 08 May 2025 22:44:24 +0200

Main reference:

Understanding the Linux Kernel 3rd Edition, Daniel P.Bovet and Marco Cesati.

TODOs:

preempt_count

General Rule
kernel preemption is disabled in critical region protected by spin locks

§ Quick facts

spin locks

kernel preemption is disabled in spin lock protected critical regions.
for uniprocessor system, the spin lock simply disables/enables kernel preemption

Memory Model and Formalization

i@shrik3.com (SHRIK3) — Wed, 07 May 2025 18:37:40 +0200

since the formal language (+model checking, formal verification etc.) is new knowledge to me, I’d like to repeat them here for a quick reference.

MC-02h - memory constency intro & sequential consistency

i@shrik3.com (SHRIK3) — Tue, 06 May 2025 16:24:55 +0200

[back to index]

without further notes, all contents are copy-verbatim or derived from Chapter 3 of

A Primer on Memory Consistency and Cache Coherence (2nd Edition), Synthesis Lectures on Computer Architecture, Vijay Nagarajan, Daniel J.Sorin, Mark D.Hill and David A. Wold
https://pages.cs.wisc.edu/~markhill/papers/primer2020_2nd_edition.pdf

this page is under CC-BY-SA-4.0. The above notice must be preserved.

§ Memory Reordering - Intro

Example of memory reordering: core 2 spins upon flag. Programmer may assume Core 2 reads r2 == NEW because Core 1 sets data before setting flag. However S1 and S2 could get reordered, thus Core 2 exits the spin and reads old data before NEW is stored.

data = OLD; flag = !SET;
// core 1 S1: store data = NEW; S2: store data = SET;	// core 2 L1: Load r1 = flag; B1: if (r1 != SET) goto L1; L2: Load r2 = data;

Sequential execution (von Neumann) model generally requires that operations to the same address execute in the original program order. The reordering discussed only happen on access to different addresses.

How a core might reorder memory access.

Store-store reordering
Load-load reordering
Load-store and store-load reordering

§ Sequential Consistency (SC)

MC-01h - coherence introduction

i@shrik3.com (SHRIK3) — Mon, 05 May 2025 15:19:45 +0200

[back to index]

without further notes, all contents are copy-verbatim or derived from Chapter 2 of

this page is under CC-BY-SA-4.0. The above notice must be preserved.

§ reference system (fig. 2.1)


+---------------------------------------------------------------+
|                                                               |
|   +----+                  +----+                              |
|   |Core|                  |Core|                              |
|   +----+                  +----|                              |
|    | ^                     | ^                                |
|    V |                     V |                                |
|   +--+--+     +-+         +-----+      +-+                    |
|   |Cache| <-> |P| ``````` |Cache| <->  |P|    (L1 and L2)     |
|   |Ctrlr|     |C|         |Ctrlr|      |C|                    |
|   +-----+     +-+         +-----+      +-+                    |
|     | ^                     | ^                               |
|     | |                     | |                               |
|     V |                     V |                               |
|   ------------------------------------------------            |
|               Interconnection Network                         |
|   ------------------------------------------------            |
|     | ^                                                       |
|     | |                                                       |
|     V |                                                       |
|   +-------------+     +-----+                 (L3 cache)      |
|   | LLC/Memory  | <-> | LLC |                                 |
|   | Controller  |     +-----+                                 |
|   +-------------+                                 Multicore   |
|       |   ^                                       Processor   |
|       |   |                                       Chip        |
+-------|---|---------------------------------------------------+
        |   |           
        V   |
    +-------+------+
    | Main Memory  |
    +--------------+


The multicore processor chip consists of multiple single-threaded cores.
- Each core has its own private data cache (PC).
- Last-level cache (LLC) is shared by all cores (commonly the L3 cache).
- LLC is logically a "memory-side cache", thus not part of cache-coherence.
- LLC also serves as on-chip memory controller (?)

Omitted from baseline diagram:
- instruction cachees, Multiple-level caches, caches shared among cores (not
  LLC), virtually addressed caches
- TLBs
- DMA

§ Cache Coherence Interface / Coherence Protocol

The processor cores interact with the coherence protocol (next) through a coherence interface via two methods

read-request : read(addr) -> value
write-request : write(addr, addr) -> ack

The coherence protocols can be classified into two categories based on the nature of their coherence interfaces: whether there is a clean separation of cohreence from consistency model, or whether they are indivisible

Consistency-agnostic coherence
a write is made visible to all other cores before returning; writes are propagated synchronously. The cache coherence protocol abstracts aways the caches completely and presents an illusion of atomic memory (i.e. no caches present). The ordering madated by the consistency model specs are enforced by the core pipeline. (or .. the cache coherence is entirely separated from the consistency model.)

Consistency-directed coherence
a write can return before it has been made visible to all processors, (writes are propagated asynchronously) allowing for stale values (in real time) to be observed). This class of coherence protocol must also ensure that the consistency model (or, memory ordering) is observed.

§ Defining Consistency-agnostic Coherence via Invariants

There are multiple ways of defining this coherence. One is through a set of two invariants.

Single-Writer, Multiple-Read (SWMR) Invariant. For any memory location A, at any given time, there exists only a single core that may write to A (and can also read it), OR some number of cores that may only read A. (pretty much the classical synchronization problem)
Data-Value Invariant.. The value of the memory location at the start of an epoch is the same as the value of the memory location at the end of its last read-write epoch.

Notation for each memory location, its lifetime is divided up into epochs.

SWMR: in each epoch, either a single core has read-write access or some number of cores (possibly zero) have read-only access.
In the following example, SWMR alone does not ensure that e.g. the write from core 3 is observed by core 1 read. To ensure the cache does not break memory consistency additional invariant is required.

                                                                TIME
|---------------+---------------+---------------+------------------->
| Read-only     | Read-write    | Read-write    | Read-only
| Cores 2, 5    | Core 3        | Core 1        | Cores 1,2 and 3

There are other (equivalent) definition of the same coherence (sidebar in sec.2.4)

When is coherence relevant?

Coherence pertains to all storage structures that hold blocks from the shared address space. Including L1 data cache, L2 cache, LLC and main memory; also L1 instruction cache and TLBs
Coherence is not directly visible to the programmer. Processor pipeline and coherence protocol jointly enforce the consistency model. Only the consistency model is visible to the programmer.

§ Some remarks

In practice, coherence is usually maintained at the granularity of cache blocks.
A coherence protocol must ensure that writes are made visible to all processors
Safety invariant : badthings must not happen. Liveness invariant: good things must eventually happen

ECC memory and bitflip handling

i@shrik3.com (SHRIK3) — Wed, 30 Apr 2025 18:30:03 +0200

GOAL: understand how ECC hardware works & how the event propogates to the operating system (e.g. via interrupts)

reads:

some notes from Andi Kleen:
https://www.halobates.de/

Linux kernel boot messages and seeing if your AMD system has ECC
https://utcc.utoronto.ca/~cks/space/blog/linux/AMDWithECCKernelMessages?showcomments

[PATCH EDACv2 00/12] Add a driver to report Firmware first errors (via GHES)
https://lore.kernel.org/all/cover.1361459782.git.mchehab@redhat.com/

Machine check handling on Linux
https://www.halobates.de/mce.pdf

Ongoing evolution of Linux x86 machine check handling https://halobates.de/mce-lc09-2.pdf

§ ECC hardware:

ECC memory controller
on-chip (internal) error-correction circuits on DRAM chips
EOS memory modules

MCA recovery (since Nehalem-EX CPU)

§ Intel CMCI (corrected machine check interupt)

CMCI via local APIC: INTEL SDM, 15.5 CORRECTED MACHINE CHECK ERROR INTERRUPT

MSRs

    MSR 0x00000179
    IA32_MCG_CAP[10] (BIT 10)

    MCG_CMCI_P (Corrected MC error counting/signaling extension present) flag
    Indicates (when set) that extended state and associated MSRs necessary to
    support the reporting of an interrupt on a corrected MC error event and/or count
    threshold of corrected MC errors, is present. When this bit is set, it does not
    imply this feature is supported across all banks. Software should check the
    availability of the necessary logic on a bank by bank basis when using this
    signaling capability (i.e., bit 30 settable in individual IA32_MCi_CTL2 register)

CORRECTED ERROR FLOW (s)

mcelog (CMCI loged through /dev/mcelog) + decoding. Deprecated since 4.12
```
CONFIG_X86_MCELOG_LEGACY=y
# enable /dev/mcelog
```
OR polling

CMCI support in kernel:

88ccbedd9ca85d1aca6a6f99df48dce87b7c02d4
x86, mce, cmci: add CMCI support

b276268631af3a1b0df871e10d19d492f0513d4b
x86, mce, cmci: factor out threshold interrupt handler (the irq handler)

https://wiki.osdev.org/APIC
https://linux-kernel.vger.kernel.narkive.com/pFTxqtbj/patch-0-9-x86-cmci-add-support-for-intel-cmci
https://lore.kernel.org/lkml/20230718210813.291190-1-tony.luck@intel.com/T/

§ OS and Software

x86 booting options


Please see Documentation/arch/x86/x86_64/machinecheck.rst for sysfs runtime tunables.

mce=off
    Disable machine check
mce=no_cmci
    Disable CMCI(Corrected Machine Check Interrupt) that
    Intel processor supports.  Usually this disablement is
    not recommended, but it might be handy if your hardware
    is misbehaving.
    Note that you'll get more problems without CMCI than with
    due to the shared banks, i.e. you might get duplicated
    error logs.
mce=dont_log_ce
    Don't make logs for corrected errors.  All events reported
    as corrected are silently cleared by OS.
    This option will be useful if you have no interest in any
    of corrected errors.
mce=ignore_ce
    Disable features for corrected errors, e.g. polling timer
    and CMCI.  All events reported as corrected are not cleared
    by OS and remained in its error banks.
    Usually this disablement is not recommended, however if
    there is an agent checking/clearing corrected errors
    (e.g. BIOS or hardware monitoring applications), conflicting
    with OS's error handling, and you cannot deactivate the agent,
    then this option will be a help.
mce=no_lmce
    Do not opt-in to Local MCE delivery. Use legacy method
    to broadcast MCEs.
mce=bootlog
    Enable logging of machine checks left over from booting.
    Disabled by default on AMD Fam10h and older because some BIOS
    leave bogus ones.
    If your BIOS doesn't do that it's a good idea to enable though
    to make sure you log even machine check events that result
    in a reboot. On Intel systems it is enabled by default.
mce=nobootlog
    Disable boot machine check logging.
mce=monarchtimeout (number)
    monarchtimeout:
    Sets the time in us to wait for other CPUs on machine checks. 0
    to disable.
mce=bios_cmci_threshold
    Don't overwrite the bios-set CMCI threshold. This boot option
    prevents Linux from overwriting the CMCI threshold set by the
    bios. Without this option, Linux always sets the CMCI
    threshold to 1. Enabling this may make memory predictive failure
    analysis less effective if the bios sets thresholds for memory
    errors since we will not see details for all errors.
mce=recovery
    Force-enable recoverable machine check code paths

nomce (for compatibility with i386)
    same as mce=off

Everything else is in sysfs now.

§ Physical Format, Chips and Memory Rank

§ Reference

MCE (Machine Check Exception)

Hardware Specs

Intel SDM Volume 3, Chapter 15 Machine-Check Architecture

APEI

EINJ

kernel

Misc

Rowhammer, https://en.wikipedia.org/wiki/Row_hammer

§ Glossary

MCE : Machine Check Exception
CMCI : Corrected Machine-Check Interrupt
SEC-DED : Single-Error-Correction, Double-Error-Detection. ECC hardware that is able to correct single bit flip and detect double big flips.

Physical formats:

SIMM : Single In-line Memory Module
DIMM : Dual In-line Memory Module
SO-DIMM : Small Outline DIMM

l4RE hands-on : basic concepts

i@shrik3.com (SHRIK3) — Tue, 29 Apr 2025 16:09:47 +0200

return to index

This note is taken away from the following sources. Re-distributions MUST preserve the attributions.

L4RE documentations

From TU Dresden Lecture “Microkernel-based Operating Systems”

“Interoduction”, Jan Bierbaum and Carsten Weinhold, TU Dresden, 15.Okt.2024
“Inter-Process Communication”, Nils Asmussen, TU Dresden, 29.Okt.2024

From TU Dresden Lecture “Microkernel Construction” by Nils Asmussen et. al.

§ L4RE ARCH


┌─────────────┐  ┌─────────────┐  ┌─────────────┐      
│ APPLICATION │  │ APPLICATION │  │ APPLICATION │ USER APPS.
└─────────────┘  └─────────────┘  └─────────────┘      
                                                  
┌──────────────┐ ┌─────────────┐  ┌────────────┐  
│FILE SYSTEMS  │ │ NETWORKING, │  │ MEMORY     │  KERN COMPONENTS
│VFS / FS IMPL.│ │ SOCKETS,    │  │ MANAGEMENT │  SHIFTED TO USER
│              │ │ PROTOCOLS   │  │            │  SPACE
└──────────────┘ └─────────────┘  │ PAGE ALOC. │  
┌──────────────────────────────┐  │ SWAPPING   │  SERVICES
│DEVICE DRIVERS                │  │            │  
└──────────────────────────────┘  └────────────┘  
                                                  USER MODE
───────────────────────────────────────────────────────────────────
                                                  KERN MODE
┌──────────────────────────────────────────────┐    
│                                              │   
│  ┌──────────────────────┬──────────────────┐ │    
│  │ SYSCALL INTERFACE    │ ADDRESS SPACE,   │ │  A MINIMAL KERN.
│  ├──────────────────────┤ THREADS,IPC,     │ │    
│  │ HARDWARE ACCESS      │ SCHEDULING       │ │    
│  └──────────────────────┴──────────────────┘ │    
│                                              │    
│ Microkernel                                  │    
└──────────────────────────────────────────────┘    
                                                       
................................................
                                                               
┌───────────────────────────────────────────────┐    
│   HARDWARE CPU, MEMORY, PCI, DEVICES ....     │    
└───────────────────────────────────────────────┘    

            Fig.1 L4 microkernel architecture

                                                                        
Slide 8, "Microkernel-based Operating Systems - Interoduction"      
Jan Bierbaum and Carsten Weinhold, TU Dresden, 15.Okt.2024

§ OBJECTS AND CAPABILITIES

Everything is an object (S.24 of ¹): Task, Thread, IPC Gate, IRQ, Factory…

Tasks hold references to kernel objects in their respective Object space, which is a kernel-protected table. These references are called capabilities. ²

Kernel (or services) exposes handles (objects) to tasks, restrained in their task-local capability space. In other words, the capability space is is the task name space of the system objects. The task can only invoke system functions via the objects assigned (mapped) to them. The object (capability) name space is configured by the task’s creator. (some sort of tree-hierarchy)


┌────────┐                                              ┌───────────┐
│ CLIENT │                                              │ SERVICE 1 │
└────┬───┘                                              └──────▲────┘
     │invoke(capability(3))                                    │     
     │    ┌───────────────────────────────────────────────┐    │     
     │    │   ┌───┐                                       │    │     
     │    │   │ 1 │                                       │    │     
     │    │   ├───┤           ┌────────────────────────┐  │    │     
     │    │   │ 2 │           │IPC GATE: COMM. CHANNEL │  │    │     
     │    │   ├───┤           │          FOR SERVICE 1 │  │    │     
     └────┼──►│ 3 ├──────────►│                        ├──┼────┘     
          │   ├───┤           └────────────────────────┘  │          
          │   │ 4 │                                       │          
          │   └───┘                                       │          
          │   TASK CAPS TABLE            KERNEL           │          
          └───────────────────────────────────────────────┘          

            Fig.2 Client - Service communication via task cap

                                                                         
        ┌──────┐      ┌────────┐               ┌───────────────┐           
        │      │ IRQ  │        │invoke_object  │ USER SPACE    │           
        │DEVICE├──────► KERNEL ├───────────────► DEVICE DRIVER │           
        │      │      │        │(irq_cap,...)  │               │           
        └──────┘      └────────┘               └───────────────┘           
                                                                             
            Fig.3 IRQ handling with user space device driver


Slide 29 and 34, "Microkernel-based Operating Systems - Interoduction"
Jan Bierbaum and Carsten Weinhold, TU Dresden, 15.Okt.2024

§ TASK, THREAD, ADDRESS SPACE

§ COMMUNICATION: IPC GATE (WIP)

Some basic facts about L4 IPC

is always synchronous ³
invokes a subroutine in a different context (context switch?)
provides the only (non-debugging) way of syscalls

UTCB (User-level Thread Control Block)

Message Registers (syscall params)
Buffer Registers (flexpage)
Thread Control Registers (thread-private data …)

§ BASIC USERMODE L4RE COMPONENTS (pkg/l4re-core/)

User-level libraries: uClibC, libstdc++, IPC client/server framework …
Task loader: Ned (init process)
Basic Resource Manager: Moe (root task, provides various abstractions). Sigma0 (memory management)

§ acronyms and things

L4RE

L4RE: L4 Runtime Environment
UTCB : user-level control block
recursive address spaces, flexpage

NOVA concepts

Protection Domain (PD) ~= Task : {objet, memory, I/O}
Execution Context (EC) ~= Thread : entity that executes code (user / kernel); Belongs to exactly one PD and not migratable (pinned on cpu)
Scueduling Context (SC) : SC supplies EC with time.
Portal (PT) ~= IPC Gate, Endpoint for syncronous IPC
IRQ interrupts represented as semaphores (NOVA)

The diagrams use extended ascii charset. If they look weird check your fonts.

“Microkernel-based Operating Systems - Interoduction”
Jan Bierbaum and Carsten Weinhold, TU Dresden, 15.Okt.2024 ↩︎
L4RE Documentations, Architecture Concepts
https://l4re.org/detailed_introduction/architecture_concepts/index.html ↩︎
there are exceptions but out-of-scope at the moment … ↩︎

frequenctly used

i@shrik3.com (SHRIK3) — Thu, 10 Apr 2025 14:42:19 +0200

Debian Package Tracker
https://tracker.debian.org/

git notes
https://sys.shrik3.com/tooling/git/git.html

gpg notes
https://sys.shrik3.com/tooling/gpg/commands.html

Debian wiki: Using OpenPGP subkeys in Debian development
https://wiki.debian.org/Subkeys

pleroma maintainece notes

i@shrik3.com (SHRIK3) — Wed, 09 Apr 2025 10:41:44 +0200

§ step 0:

always check the release pages for breaking changes.
make sure you have proper backups
use e.g. tmux so that your session is not interrupted by internet conditions

Important docs

§ backups

[+] click to expand a sample pleroma backup script

assuming pleroma is installed from source

!!! do not run scripts from internet without knowing what it does !!!

# CHANGE THIS TO YOUR OWN CONFIG
PLEROMA_DB=pleroma              # name of the database
BACKUP_DIR=/backups             # path to backup storage
PLEROMA_INSTALL=/opt/pleroma    # path to pleroma installation
PLEROMA_UPLOADS=/srv/pleroma    # optionally you can backup pleroma statics (FEs, emojis, uploads etc.)

POSTGRES_USER=postgres          # system user for postgresql, 
                                # by default it would be "postgres"

# you may want a timestamp for automated backups
TIMESTAMP=$(date +%Y-%m-%d_%H-%M-%S)

# use a temporary dir to collect all the data to create the final archive.
DUMP_DIR=/tmp/pleroma_dump/$TIMESTAMP
mkdir -p $DUMP_DIR

# dump the database(s)
sudo pg_dump --username=$POSTGRES_USER -d $PLEROMA_DB --format=custom -f $DUMP_DIR/postgres.dump

# you may want to check the return code for the previous command.

# backup important pleroma configs (optionally you could backup the whole
# pleroma production installation (e.g. /opt/pleroma)
cp $PLEROMA_INSTALL/config/prod.secret.exs $DUMP_DIR/prod.secret.exs
cp $PLEROMA_INSTALL/config/setup_db.psql $DUMP_DIR/setup_db.psql

# create an archive
tar -czvf  $BACKUP_DIR/$TIMESTAMP.tar.gz -C $DUMP_DIR . -C $PLEROMA_UPLOADS . >> /dev/null

# check results and remove the temporary dir
if [ $? -eq 0 ]; then
    echo [$TIMESTAMP] archive created
    rm -rf $DUMP_DIR
fi

§ upgrade postgresql (+migration)

You need to manually migrate the postgresql database when updating the postgres by major version, e.g. from 14.x to 15.y; You don’t have to do this when updating from e.g. 14.x to 14.y

Supposing upgrading from 14.x to 15.y, you need to make sure the 14.x postgresql binary is still available when doing the migration.

archlinux provides the postgresql-old-upgrade package which provides the postgresql binary 1 version behind the main repo postgresql.

My notes on upgrading pg

Here are some quick notes, but make sure you know what you are doing.

make sure you have a proper backup
stop postgresql service: systemctl stop postgresql
update the postgresql binary and make sure you keep the old binary (see above)
run the following:

# prepare dirs for live data migration

mv /var/lib/postgres/data /var/lib/postgres/olddata
mkdir /var/lib/postgres/data /var/lib/postgres/tmp
chown postgres:postgres /var/lib/postgres/data /var/lib/postgres/tmp

# switch to postgres user 
sudo -iu postgres

# go to tmp dir and perform migration
cd /var/lib/postgres/tmp

# initialize the "new" DB. You'll need the parameters that you used to
# intialize the postgresql db for the first time. (if you follow pleroma
# installation guide this should be empty.)
initdb -D /var/lib/postgres/data --PARAMETERS_USED_TO_INIT_DB

# perform migration:
pg_upgrade -b /opt/pgsql-PG_VERSION/bin -B /usr/bin -d /var/lib/postgres/olddata -D /var/lib/postgres/data

# restart postgresql

for archlinux

optionally, to avoid suprises, do not update postgresql packages.

warning: postgresql: ignoring package upgrade (16.3-4 => 17.4-1) │ warning: postgresql-libs: ignoring package upgrade (16.3-4 => 17.4-1) │ warning: postgresql-old-upgrade: ignoring package upgrade (15.7-3 => 16.6-2)

§ install (update) pleroma from source

https://docs-develop.pleroma.social/backend/administration/updating/

the DWARF Debugging Information Format (V5)

i@shrik3.com (SHRIK3) — Tue, 04 Mar 2025 13:42:09 +0100

This post is a hash of the fucking manual: https://dwarfstd.org/doc/DWARF5.pdf

read

i@shrik3.com (SHRIK3) — Fri, 28 Feb 2025 13:00:04 +0100

volatile page for stuffs I read. With some takeaways and comments.

DNA sequencing fact sheet
this is not helping at all.

bioshocks (pun intended!)

i@shrik3.com (SHRIK3) — Thu, 27 Feb 2025 23:04:23 +0100

https://www.genome.gov/about-genomics/fact-sheets/DNA-Sequencing-Fact-Sheet

One new sequencing technology involves watching DNA polymerase molecules as they copy DNA - the same molecules that make new copies of DNA in our cells - with a very fast movie camera and microscope […]

Wait ….. what…. movie camera????

glossary

i@shrik3.com (SHRIK3) — Thu, 27 Feb 2025 23:00:15 +0100

BACK TO INDEX

polymerase: Any of various enzymes that catalyze the formation of polymers of DNA or RNA using an existing strand of RNA or DNA respectively as a template.
in silico (in silicon): performed on a computer or via simulation
in vitro (in glass): performed outside their normal biological context: in test-tube
in vivo: performed in their living organism

python package management and virtual env

i@shrik3.com (SHRIK3) — Thu, 27 Feb 2025 12:44:53 +0100

I’m always scared away by python dependecy management. I’m always pissed off when I’m trying to install a pip package only to conflict with the system managed ones. Now I fainally take the chance to take a look at venv.

§ How does python (pip) manage packages?

AW: they fuck you.

§ How does linux distro manage python packages?

AW: they fuck you.

§ the venv (python 3.3+)

# create
$ python -m venv <name>   # python 3.3
$ virtualenv <name>       # python 3

# activate
$ source envname/bin/activate

# deactive
$ deactivate  # (while in virtenv)

bits 0x55 - CW 9 - 26, 2025

i@shrik3.com (SHRIK3) — Thu, 27 Feb 2025 11:30:17 +0100

It has been a long time. But I finally got my sanity back (spelt: thesis handed in). Anyways…

§§§ AI create more X-Y problems

So I see people talk on social media :

“I want to remove all blank lines form a text document, AI tools {A,B} don’t work, C works, wow amazing, here is how.”

Honestly if you spare one minute searching the internet:

Search for how to remove blank lines with [editor X], and you will immediately get a straight-forward solution. (mind you, these are literally the first entry from google search.

“delete empty lines vim”

:g/^$/d

“delete empty lines vscode”

Ctrl-H -> use regular expressions -> ^$\n -> replace all

“delete empty lines emacs”

M-x flush-lines RET ^$ RET

“delete empty lines notepad++”

edit -> line operations -> remove empty lines

…

See? Instead of these you decide to paste your whole document to a chatbot and let it do it for you. How do you know it only removes the black lines?

So I say it again: AI creates more X-Y problems.

You have a solid problem
instead of solving the problem
you go after “how to prompt the AI to do it for me”.

§§§ shitphone experience

I’m traveling. However my phone has a failing battery and I have no intention to pick a new one as my main phone—the old one can be revived with a new battery. I need some safety for my travel … so I bought a cheap cheap backup phone for 65 euros brand new. To be specific it is a Redmi A3.

I have literally zero expectation from that thing. As long as it connects to the internet I’m happy. But setting it up is absofuckinglutely painful.

It asks you a bunch of questions, as for a google login, as you to agree to tons of stuffs. Fine, I won’t give you sensitive information anyways.

Then it proceeds to “set up your phone”, which is, installing more than 20 of APPs, including shit games, shit social media, shit streaming service. None I’ve ever asked for, or given the option to opt-in/out. And this process takes like an HOUR. Not including me removing those spyware.

I guess installing those sponsored APPs is how they make this phone cheap.

§§§ Good Reads

An Attempt to Catch Up with JIT Compilers—The False Lead of Optimizing Inline Caches. (Poirier et. al.)
https://arxiv.org/pdf/2502.20547

Contemp Culture - aurynn shaw

Systemd as tragedy

Does X cause Y? An in-depth evidence review

Modern-Day Oracles or Bullshit Machines?
hmmm. perhaps a good one(s) for the non-techies to de-mystify the AI superstition. However it reads way too subjective and I definitely hate the format: it’s like an apple product page. Can’t you just give me a text wall?

§§§ num num num

I have accumulated quite a few to-reads at @bookmarks. I see interesting stuffs floating around that I don’t have the time to read. Now that I have some time I’ll spend some time chewing some of them.

I have some bookmarks on “system tracing”, especially in the linux eco-system. I’m making a standalone folder for this

§§§ git practice

I’m thinking about adapting a new git workflow. Namely bare-repo + worktree

for a non-ad-hoc work (e.g. nya)

have a local clone into a bare repo (under ~/repos/nya)
for a master/feature/bugfix, check out the branch into its own worktree (eng. under ~/projs/nya/{dev,feat1,fix_xyz})
delete the worktree once the branch is commited

~/repos/                ~/proj/
    |_ repo1 ------+--> |_ repo1_bugfix
    |              +--> |_ repo1_feature2
    |                   |
    |_ repo2 (stale)    |
    |                   |
    |_ repo3 ---------> |_ repo3_dev

How to trasform an existing repo into bare one (tested, won’t break existing worktrees)

SO answer:
https://stackoverflow.com/a/2200662

In short:

commit your work if any, otherwise you will lose them

replace your repo content with content under .git

mv repo/.git repo.git
rm -rf repo
mv repo.git repo

config git into bare repo

cd repo
`git config --bool core.bare true`

optionally, git worktree repair/prune to repair/remove broken worktrees

§§§ Okay. Let’s take this seriously.

since I’ll officially start working for the university from July..

bits worth learning

i@shrik3.com (SHRIK3) — Mon, 17 Feb 2025 00:18:18 +0100

if(NULL == thing){} as a sanity check. When (by mistake) writing == as =, if(thing = NULL){} is error-prone yet valid C code.. while if(NULL = thing) is a compilation error.

pv (pipe viewer) - manipulate pipe and stream

i@shrik3.com (SHRIK3) — Mon, 17 Feb 2025 00:08:02 +0100

Project URL: https://www.ivarch.com/programs/pv.shtml
Code snippets under GPL-3.0-or-later
Text under CC-BY-SA-4.0

site map

i@shrik3.com (SHRIK3) — Mon, 10 Feb 2025 00:27:36 +0100

sorry for the mess…I’ll clean up, I promise

MAIN:

HOME and ABOUT
POSTS : regular posts
NOTES : technical notes I keep for myself
MUSIC : my music
VIS : some photos or arts
IRL : boring irl stuffs
RANTS : tech related shitposting
TAKE : non-tech related shitposting
RAND : even more shitposting
CODE READING : … code reading
PAPER READING : … paper reading
VOLATILE : frequently updated, drafts
BITS : journals

MISC / AD-HOC

BOOKMARKS : stuffs I read or want to read
LOG : 碎碎念

OTHER SITES

SYS : a system programming wiki I maintain

infrasturctures

i@shrik3.com (SHRIK3) — Tue, 04 Feb 2025 21:35:00 +0100

I’m been wondering what’s running behind the scenes. I see system admins talking about prices from time to time, so I take notes.

没吃过猪肉，还没见过猪跑吗

Case: linux mirror (Jan. 2025)

https://social.kernel.org/notice/AqmnBVqyAncjoVhdNw

mirrors.kernel.org transfers ~1PiB of data weekly. At Equinix Metal’s list price of $0.05 per GB, it would cost us roughly$ 200, 000 a month to operate these systems

Case: freedesktop’s gitlab servers (Jan. 2025)

A very insightful post from FDO’s system admin.

https://web.archive.org/web/20250203121213/https://gitlab.freedesktop.org/freedesktop/freedesktop/-/issues/2011

Case: elxir.bootlin .. the source code indexer

At Bootlin, here are a few details about the server we’re using: As of July 2019, our Elixir service consumes 17 GB of data (supporting all projects), or for the Linux kernel alone (version 5.2 being the latest), 12 GB for indexing data, and 2 GB for the git repository.

We’re using an LXD instance with 8 GB of RAM on a cloud server with 8 CPU cores running at 3.1 GHz.
https://github.com/bootlin/elixir

libcommon (todo)

i@shrik3.com (SHRIK3) — Tue, 04 Feb 2025 16:26:21 +0100

maybe some stuffs to learn from.

https://github.com/CM4all/libcommon

https://intersec.github.io/lib-common/lib-common/philosophy.html

gettext library : i18n for c

i@shrik3.com (SHRIK3) — Tue, 04 Feb 2025 16:13:25 +0100

So in another code reading note I looked into some “standard” initialzation routines of a typical GNU (coreutils) program. And a good chunk of the initialzation is regarding localization (i18n). Here are more notes on this topic.

Well I saw something like this _("text") and was like … is there a C syntax rule I don’t know?

Then realized it’s a fucking function called _() .. e.g.

#define _(Text) gettext (Text)

man 3 gettext

NAME
       gettext, dgettext, dcgettext - translate message

SYNOPSIS
       #include <libintl.h>

       char * gettext (const char * msgid);
       char * dgettext (const char * domainname, const char * msgid);
       char * dcgettext (const char * domainname, const char * msgid,
                         int category);

DESCRIPTION
       The  gettext,  dgettext  and  dcgettext functions attempt to translate a text string into the user's native lan‐
       guage, by looking up the translation in a message catalog.

enabling sysrq

i@shrik3.com (SHRIK3) — Mon, 03 Feb 2025 12:56:41 +0100

sysrq is a lowlevel keybinding implemented in the kernel to debug the system when it’s not responsive.

§ enable on archlinux (systemd)

on archlinux sysrq is disabled by default.

via. changing kernel parameters

by default the sysrq parameter only allows “sync”.

$ (sudo) sysctl --system
kernel.sysrq = 16 (0x10)
# note this command will bring your sysctl config to system default.
# if you already have manual settings they may get lost.

Configurations ¹

  0 =   0x0 - disable sysrq completely
  1 =   0x1 - enable all sysrq functions

  2 =   0x2 - enable control of console logging level
  4 =   0x4 - enable control of keyboard (SAK, unraw)
  8 =   0x8 - enable debugging dumps of processes etc.
 16 =  0x10 - enable sync command
 32 =  0x20 - enable remount read-only
 64 =  0x40 - enable signalling of processes (term, kill, oom-kill)
128 =  0x80 - allow reboot/poweroff
256 = 0x100 - allow nicing of all RT tasks

do with care

# replace N with proper permission bits. Use 1 to enable all
# via sysctl
sysctl kernel.sysrq=<N>
# or via proc fs
echo "<N>" > /proc/sys/kernel/sysrq

persistent config: modify /etc/sysctl.d/<parameter file>

kernel.sysrq = <N>

§ use

on x86: Alt-SysRq-CommandKey. Or Alt-PrintScreen-CommandKey.

(my case) where PrintScreen needs Fn to trigger (Home and PrtScr on the same key): Keep holding down Alt, press Fn + Home(PrtScr), then release Fn+ Home(PrtScr) (keep Alt pressed, then press the CommandKey

Example usage:

in case the display server freezes (xorg, wayland …) and doesn’t respond to keboard, can use Sysrq + r to “unraw” the keyboard mode, then bring up the tty using Ctrl+Alt+F<1234>.
“recover” the keyboard mode from Sysrq+r, if you fixed your issue and dicide to continue using the system without rebooting.
```
$ sudo kbd_mode -s -C /dev/ttyN
```
where /dev/ttyN poitns to the tty that X (or wayland) is running. To figure that out, perhaps use sudo fgconsole

[+] click to expand the commandkeys

see doc for details

CommandKey

b Will immediately reboot the system without syncing or unmounting your disks.
c Will perform a system crash and a crashdump will be taken if configured.
d Shows all locks that are held.
e Send a SIGTERM to all processes, except for init.
f Will call the oom killer to kill a memory hog process, but do not panic if
  nothing can be killed.
g Used by kgdb (kernel debugger)
h Will display help (actually any other key than those listed here will display
  help. but h is easy to remember :-)
i Send a SIGKILL to all processes, except for init.
j Forcibly “Just thaw it” - filesystems frozen by the FIFREEZE ioctl.
k Secure Access Key (SAK) Kills all programs on the current virtual console.
  NOTE: See important comments below in SAK section. (see link)
l Shows a stack backtrace for all active CPUs.
m Will dump current memory info to your console.
n Used to make RT tasks nice-able
o Will shut your system off (if configured and supported).
p Will dump the current registers and flags to your console.
q Will dump per CPU lists of all armed hrtimers (but NOT regular timer_list
  timers) and detailed information about all clockevent devices.
r Turns off keyboard raw mode and sets it to XLATE.
s Will attempt to sync all mounted filesystems.
t Will dump a list of current tasks and their information to your console.
u Will attempt to remount all mounted filesystems read-only.
v Forcefully restores framebuffer console
v Causes ETM buffer dump [ARM-specific]
w Dumps tasks that are in uninterruptible (blocked) state.
x Used by xmon interface on ppc/powerpc platforms. Show global PMU Registers on
  sparc64. Dump all TLB entries on MIPS.
y Show global CPU Registers [SPARC-64 specific]
z Dump the ftrace buffer

0-9

Sets the console log level, controlling which kernel messages will be printed to
your console. (0, for example would make it so that only emergency messages like
PANICs or OOPSes would make it to your console.)

R: Replay the kernel log messages on consoles.

§ more context

what is “raw” keyboard mode
https://unix.stackexchange.com/questions/16530/

I think that’s a post on its own about how keyboard works. Basically there are kbd_mode, man 1 kbd_mode

-s scancode (RAW)
-k keycode (MEDUIMRAW)
-a ASCII (XLATE): Sysrq + r sets kbd mode to this.
-u UTF-8 (UNICODE)

Extra: kbdkbmode (since linux 2.6.39) can be set to K_OFF (0x04). Which is the case for my environment (wayland/sway). Interestingly kbd_mode doesn’t support this yet. (And it tells me the keyboard is in “UNKNOWN” mode)

HA…

§ see also

https://docs.kernel.org/admin-guide/sysrq.html ↩︎

COLLECTION OF DEV TOOLS

i@shrik3.com (SHRIK3) — Mon, 03 Feb 2025 11:54:16 +0100

what was that tool called, that does …

prifiling, benchmarking

ptrace
ftrace
strace
ltrace
perf
- flamegraph

binary

misc

kernelshark
kcov
gcov

device tree (linux) /// WIP

i@shrik3.com (SHRIK3) — Thu, 30 Jan 2025 19:31:33 +0100

refs:

Kunststoff

i@shrik3.com (SHRIK3) — Thu, 30 Jan 2025 11:37:55 +0100

This is a quick reference, do fact checks yourself.

Recycle Numbers

#  Name     Food    Food+Heat   e.g. Usage              NOTE
------------------------------------------------------------------------------
1  PET      YES?    70  °C      drinks bottles          Do not reuse for food
2  HDPE     YES                 cutting board
3  PVC      NO                                          NOT FOR FOOD !
4  LDPE     YES                 plastic bags
5  PP       YES     160 °C      food/drinks
6  PS/EPS   NO
7  Others   NO                                          NOT FOR FOOD !


there are other materials not listed (i.e. not recycble)

- tritan (at least heavily advertised) for reused watter bottles

rule of thumb:

use ceramic / glass if applicable
make sure BPA free

refs:

TODOs in linux code reading

i@shrik3.com (SHRIK3) — Wed, 29 Jan 2025 20:46:57 +0100

Index (aha)
https://lwn.net/Kernel/Index/

Four short stories about preempt_count()
https://lwn.net/Articles/831678/

An end to high memory?
https://lwn.net/Articles/813201/

(kernel doc) high memory handling https://www.kernel.org/doc/Documentation/vm/highmem.txt

On not getting burned by kmap_atomic()
https://lwn.net/Articles/111226/

The future of the page cache https://lwn.net/Articles/712467/

https://lwn.net/Kernel/Index/#kmap_atomic

x86: Put hot per CPU variables into a struct

i@shrik3.com (SHRIK3) — Wed, 29 Jan 2025 20:22:59 +0100

https://lore.kernel.org/lkml/166601845607.401.14987443239536693764.tip-bot2@tip-bot2/T/

several patches changed the layout of “hot” percpu data.

e.g.

e57ef2ed Thomas Gleixner
x86: Put hot per CPU variables into a struct

64701838 Thomas Gleixner
x86/percpu: Move preempt_count next to current_task

.. importantly:

commit e57ef2ed97c1d078973298658a8096644a1e9e09
Author: Thomas Gleixner <tglx@linutronix.de>
Date:   Thu Sep 15 13:11:01 2022 +0200

    x86: Put hot per CPU variables into a struct
    
    The layout of per-cpu variables is at the mercy of the compiler. This
    can lead to random performance fluctuations from build to build.
    
    Create a structure to hold some of the hottest per-cpu variables,
    starting with current_task.

what it does

some hot per cpu stuffs are defined from multiple places

// arch/x86/include/asm/preempt.h
DECLARE_PER_CPU(int, __preempt_count);

// arch/x86/include/asm/current.h
DECLARE_PER_CPU(struct task_struct *, current_task);

// ..

they are packed into struct pcpu_hot:

// arch/x86/include/asm/current.h

struct pcpu_hot {
	union {
		struct {
			struct task_struct	*current_task;
			int			preempt_count;
			int			cpu_number;
#ifdef CONFIG_MITIGATION_CALL_DEPTH_TRACKING
			u64			call_depth;
#endif
			unsigned long		top_of_stack;
			void			*hardirq_stack_ptr;
			u16			softirq_pending;
#ifdef CONFIG_X86_64
			bool			hardirq_stack_inuse;
#else
			void			*softirq_stack_ptr;
#endif
		};
		u8	pad[64];
	};
};

DECLARE_PER_CPU_ALIGNED(struct pcpu_hot, pcpu_hot);

/* const-qualified alias to pcpu_hot, aliased by linker. */
DECLARE_PER_CPU_ALIGNED(const struct pcpu_hot __percpu_seg_override,
			const_pcpu_hot);

and

// arch/x86/kernel/cpu/common.c
DEFINE_PER_CPU_ALIGNED(struct pcpu_hot, pcpu_hot) = {
	.current_task	= &init_task,
	.preempt_count	= INIT_PREEMPT_COUNT,
	.top_of_stack	= TOP_OF_INIT_STACK,
};
EXPORT_PER_CPU_SYMBOL(pcpu_hot);
EXPORT_PER_CPU_SYMBOL(const_pcpu_hot);

access, through the pcpu struct

-	per_cpu(current_task, cpu) = idle;
+	per_cpu(pcpu_hot.current_task, cpu) = idle;

replace GnuPG with age and signify

i@shrik3.com (SHRIK3) — Wed, 29 Jan 2025 16:42:38 +0100

examples - age:

$ age-keygen -o key.txt
Public key: age1ql3z7hjy54pw3hyww5ayyfg7zqgvc7w3j2elw8zmrj2kg5sfn9aqmcac8p

$ tar cvz ~/data | age -r ${THAT_PUBKEY} > data.tar.gz.age

$ age --decrypt -i key.txt -o data.tar.gz data.tar.gz.age

# get pubkey from private key (simply open key.txt it's annotated), or
$ age-keygen -y key.txt

Generate key-pair (i.e. “identity”)

$ age-keygen -o key.txt
> Public key: age1ql3z7hjy54pw3hyww5ayyfg7zqgvc7w3j2elw8zmrj2kg5sfn9aqmcac8p

# recorver pubkey from private key (if not already annotated in key.txt)
$ age-keygen -y key.txt

# protect the identity file with passphrase (age will detect this when using)
$ age -e -p < key.txt > key.age && rm key.txt

# Or us SSH keys
$ man ssh-keygen

Encryption

$ tar -cvz DATA | age -r ${recipient pub key}  > data.tar.gz.age

# With SSH keys
$ age [...] -R ~/.ssh/public_key -o [...]

# symmetric encryption
$ age -p < data.tar.gz > data.tar.gz.age

Decryption

$ age --decrypt -i ${path_to_key} -o data.tar.gz data.tar.gz.age

# with SSH key
$ age [...] -i ~/.ssh/private_key [...]

# may also redirect output
$ age --decrypt -i ${path_to_key} data.tar.gz.age > data.tar.gz
$ age --decrypt -i ${path_to_key} data.tar.gz.age | tar -xzv

# when used on symmetrically encrypted file, age will ask for passphrase

Quick Notes

-e / --encrypt                  Do encryption
-d / --decrypt                  Do decryption
-r / --recipient=PUBKEY         Specify a recipient (inlined string)
-R / --recipients-file=PATH     Specify recipients listed in file
-p / --passphrase               Do symmetric encryption with passphrase
-a / --armor                    ANSI armored output
-i / --identity=PATH            Path to the identity file. When used with
                                encryption, the identity is also used as a
                                recipient. (-e must be explicit)
-o / --output=PATH              same as > FILE indirect

-i / –identity format options:

a. Plaintext file containing age identity (generated via age-keygen)
b. A passphrase encrypted file, as above.
c. An SSH private key file
d. "-" read from standarf input

Security

If attacker has access to both your encrypted files and yoru age pubkey,
they can replace the whole data.

If you want the files strictly encrypted to _YOURSELF_ perhaps consider
symmetric encryption.

consider storing also the hash.

Appendix (?) File integrity and authentication

First understand what attacker vector you worry about:

a.  for file integrity (against hazards) it would suffice to put the hash
    alongside the encrytped archive

    [data.age   data.age.sha256]    [pubkey]    [priv key]
    ----------------------------    -------     --------
    safe but not hazard resilient    public      safe

b.  if your pubkey (identity) is public, attacker could REPLACE your
    encrypted file (and produce a new hash). i.e. you have no idea who
    created the encrypted file. Therefore you need a signature.

    [data.age   data.age.sig]       [pubkey]    [priv/sign key]
    ------------------------         -------    ---------------
    untrusted and not resilient       public     safe

b.1 if you are using SSH keys for age, you could reuse your SSH key for
    signature. (Also checkout signify). However this approach means you
    need to distribute your keypair wherever the encryption(signing) is
    performed. This leads to a very different problem.

b.2 or, don't make your public key public; hence you effectively have a
    symmetric encryption

    [data.age   data.age.sig]       [pub/priv key, or symm key]
    ------------------------        ---------------------------
    untrusted and not resilient         safe

c.  Keep the file hashes at a different place (like somewhere safe).

    [data.tar.gz.age]               [data.tar.gz.sha256]
    -----------------               --------------------
    untrusted and not resilient         safe

Trick(s)

# don't do this
$ cat FILE | age [...]

# do this
$ age [...] << FILE

they both feed FILE content into age standard input, the later saves you one
process (cat) and the IPC (pipe)

Alternative link: - https://wth.moe/docs/age.txt

reads: - [1] https://www.latacora.com/blog/2019/07/16/the-pgp-problem/ - [2] https://words.filippo.io/dispatches/age-authentication/

per cpu variables

i@shrik3.com (SHRIK3) — Wed, 29 Jan 2025 12:09:52 +0100

mostly copy-pasted from linux insides¹. This is temporary. I’ll try to play with this hack later.

Each processor can have its own copy of a variable

The kernel creates multiple .data..percpu sections (one per-cpu) during initialization process;
All variables created with the DEFINE_PER_CPU macro will be relocated to the first section or for CPU0;
__per_cpu_offset array filled with the distance (BOOT_PERCPU_OFFSET) between .data..percpu sections;
When the per_cpu_ptr is called, for example for getting a pointer on a certain per-cpu variable for the third CPU, the __per_cpu_offset array will be accessed, where every index points to the required CPU.
there are other variants per config that put extra constraints (e.g. ARCH_NEEDS_WEAK_PER_CPU)
behinds the scene: these are compiler with some compiler

§ definitions

macros² defined in defined in percpu-defs.h

#define DEFINE_PER_CPU(type, name)                      \
	DEFINE_PER_CPU_SECTION(type, name, "")

// ...

#define DECLARE_PER_CPU_SECTION(type, name, sec)        \
	extern __PCPU_ATTRS(sec) __typeof__(type) name

#define DEFINE_PER_CPU_SECTION(type, name, sec)         \
	__PCPU_ATTRS(sec) __typeof__(type) name
#endif

after all macro expanded¹

__attribute__((section(".data..percpu"))) type name

which creates a variable in section .data..percpu. When the kernel initializes it calls the setup_per_cpu_areas function which loads the .data..percpu section multiple times, one section per CPU.¹

$ dmesg | grep percpu
[    0.043568] setup_percpu: NR_CPUS:320 nr_cpumask_bits:4 nr_cpu_ids:4 nr_node_ids:1
[    0.044069] percpu: Embedded 64 pages/cpu s225280 r8192 d28672 u524288

reference and license:

§ What per-cpu variables are there?

// arch/x86/include/asm/preempt.h

DECLARE_PER_CPU(int, __preempt_count);

// arch/x86/include/asm/current.h
// a per-cpu pointer to the currently running task struct
// NOTE: this are changed (packed into a struct pcpu_hot) with patch
// x86: Put hot per CPU variables into a struct 

DECLARE_PER_CPU(struct task_struct *, current_task);

§ TODO: play with this locally…

https://github.com/0xAX/linux-insides : CC-BY-NC-SA-4.0 ↩︎ ↩︎ ↩︎
anything from linux source tree / mailinglist : GPL-2.0-only ↩︎

ANSI escape code and OSC (terminal)

i@shrik3.com (SHRIK3) — Wed, 29 Jan 2025 10:38:08 +0100

WIP. (my brain fucking hurts)

ANSI escape code

ANSI escape sequences are a standard for in-band signaling to control cursor location, color, font styling, and other options on video text terminals and terminal emulators. Certain sequences of bytes, most starting with an ASCII escape character and a bracket character, are embedded into text. The terminal interprets these sequences as commands, rather than text to display verbatim.

https://en.wikipedia.org/wiki/ANSI_escape_code

Caret notation

it’s a notation for control characters in ASCII
^A ~ ^Z are assigned to ascii range 1-26, it’s a typable notation for the ascii code that doesn’t exist on a keyboard.
it doesn’t mean typing ^ and X verbatim
Often can be typed with Ctrl + X on keyboard

https://en.wikipedia.org/wiki/Caret_notation

C0 Control codes

(no exhaustive list)

^   C0      Abbr    Name
-----------------------------
^G  0x07    BEL     Bell
^H  0x08    BS      Backspace	
^I  0x09    HT      Tab
^J  0x0A    LF      Line Feed
^L  0x0C    FF      Form Feed
^M  0x0D    CR      Carriage Return
^[  0x1B    ESC	    Escape

C1 Control Codes
ANSI escape sequence: (Fe Escape Sequence) that is, a sequence lead by ESC

If the ESC is followed by a byte in the range 0x40 to 0x5F, the escape sequence is of type Fe. Its interpretation is delegated to the applicable C1 control code standard.
https://en.wikipedia.org/wiki/ANSI_escape_code#Fe_Escape_sequences

Most notably the Operating System Command (OSC)

ESC [   0x9B    CSI     Control Sequence Introducer
ESC \   0x9C    ST      String Terminitor
ESC ]   0x9D    OSC     Operating System Command

Operating System Command (OSC) Sequence

OSC sequence is ESC ] <constrol string> ST

This is defined by the terminal (mostly xterm)

c/c++ inline, const and static

i@shrik3.com (SHRIK3) — Tue, 28 Jan 2025 17:44:56 +0100

[back to upper dir]

§ Quick Facts

order of specifiers doesn’t matter
i.e. const static and static const are the same thing. But static should come first (convention).

static is a storage specifier, defines the visibility of a thing, affects where and how it is stored.

inside a function, static marks variables that are preserved and visible to the function across function calls.
outside a function, static means only visible to the current source file. (can’t be linked even if declared extern in other units. It modifies the symbol’s Bind attribute in the symbol table.

const is a type qualifier. It says this thing won’t change, attemps to modify it triggers compiler error¹.

outside functions, const variable (i.e. globals) only take compile-time-constant initializer
inside a function, const variable can be modified at runtime once, e.g.

static const means (indefinitely²) this variable goes to .rodata, it takes compile-time constant.

int foo(){
    const counter = bar();   // this is ok
    static const b = bar();  // this is error
    counter++;               // this is error
}

c++ static class member
Inside a class definition, the keyword static declares members that are not bound to class instances³. That is, visible to (i.e. shared by) all class instances.

c++ static class member function³

Static member functions are not associated with any object. When called, they have no this pointer.
Static member functions cannot be virtual, const, volatile, or ref-qualified.
The address of a static member function may be stored in a regular pointer to function, but not in a pointer to member function . example:

// definition
class X {
    static int n;
    static void f();
};

// static is only needed on the declarition
int X::n = 7;
void X::f() {/*whatever*/}

int X::n = 1;

c++ const member functions: denoted with const after a function declartion. It can not modify a data member of the class.

class X {
    int data;
public:
    int f() const;
    int g();
};

int X::f() {
    return data++;  // errr
}

int X::g() {
    return data++;  // ok
}

int main() {
    X foo;
    const X bar;
    foo.f();   // ok
    foo.g();   // ok
    bar.f();   // ok
    bar.g();   // error: only const functions
               // can be called on a constant class instance
}

c++ const static members: fuck me.

function that returns const thing

this is pointless because return values are rvalues

const int f() {/*return whatever*/}

this can be helpful, e.g. you have bunch of constant globals and wants to get their pointer via some functions. (and you can’t modify the backing data via the returned pointer)

const int *f(){/*whatever*/}

pointer to const and const pointer

const in funciton parameter list: use it only on pointer (pass by reference parameters).

// can not modify data via its pointer
int f(const int *data);
int f(const int *data) {
    (*data) += 1;     // error
}

// const is meaningless on a passed-by-value parameter
// same as returning a const value
int g(const int input);

who is const.

int this = 1;
int that = 42;

const int *foo = &this;  // foo is a pointer to constant int
(*foo) += 1;             // illegal, the pointed data is const
foo = &that;             // legal, the pointer itself is not const

int * const bar = &this; // bar is a constant pointer to int
(*bar) += 1;             // legal
bar = &that;             // illegal

recall: const would modify the type

// char and const char are different types
// so are their pointers
char **foo;
const char **bar;
foo = bar;  // illegal
bar = foo;  // illegal

other stuffs

inline does what it says but not a guarantee
constexpr is evaluated during compile time and used as literals
literals are things that are known at compile time and stored in read-only sections, if necessary.
static_assert assertion of a constexpr during compile time
volatile means this thing could have side effect, do not apply optimizations to it.

§ What’s inside (WIP)

§§ static (variable) inside functions

static variables are visible across function calls

#include <stdio.h>
void f(){
	static int counter = 0;
	printf("%d\n", counter);
	counter ++;
}

void g(){
	static int counter = 42;
	printf("%d\n", counter);
	counter ++;
}

int main() {
	f();    // 0
	f();    // 1
	g();    // 42
	g();    // 43
	return 0;
}

what’s inside

$ gcc -g -o test test.c
$ readelf -s test

   value            Size  Type    Bind   Vis      Ndx Name
2: 0000000000004020     4 OBJECT  LOCAL  DEFAULT   25 counter.1
3: 0000000000004018     4 OBJECT  LOCAL  DEFAULT   24 counter.0

$ readelf -S test

[SNIP]
[24] .data             PROGBITS         0000000000004008  00003008
     0000000000000014  0000000000000000  WA       0     0     8
[25] .bss              NOBITS           0000000000004018  00003018
     0000000000000010  0000000000000000  WA       0     0     4

function’s static variable names are “global”, names are mangled.
couter:1 has default value (0) therefore stored uninitialized in .BSS, while coutner:0 from g() has initial value and therefore stored in the .data section.
neither can be accessed by name from other compilation units.

§§ static outside of a function

marks a thing that is only visible inside current source file.

in foo.c

static int var1;
int var2;

in bar.c

extern int var1;
extern int var2;

#include <stdio.h>
int main() {
	printf("var1 = %d\n", var1);    // NOPE, compile error
	printf("var2 = %d\n",  var2);   // YEP
	return 0;
}

compile with gcc -o test foo.c bar.c -> compile error, var1 is undefined reference even declared extern in bar.c

This page is CC0-1.0

const variables in functions can be modified once as shown. Also you can modify a const variable via pointer magic. But why would you do that? ↩︎
of course this depends on your linker script ↩︎
https://en.cppreference.com/w/cpp/language/static ↩︎ ↩︎

no bullshit code explorer

i@shrik3.com (SHRIK3) — Tue, 28 Jan 2025 16:22:59 +0100

TL;DR: use ctags for code exploration tasks, more useable than grep and less bullshit than lsp

C syntax is pretty tricky if you want to for example grep a function’s definition. A grep regex is pretty hopeless, a lsp is too heavy, cscope is unmaintained.

#!/usr/bin/bash
#vi: tw=100

ctags -x --kinds-c=+p+x $* \
    | grep -avE "^operator |CONFIG_"  \
    | awk '{print $1"\t"$2"\t"$4":"$3}' \

use it with e.g.

1
2

# find function definitions of foo()
$ ct -R src | grep function | grep foo

you need universisal-ctags
you can modify parameters for ctags, and/or use it for other programming languages … checkout man ctags
you can apply more grep reverse matching to the pipeline to exclude unwanted patterns
awk is there is for pretty prints, e.g.
```
name    type    file:line
```

prologue of main tldr it doesn't matter

i@shrik3.com (SHRIK3) — Tue, 28 Jan 2025 13:50:20 +0100

[back to upper directory..]

Code snippets taken from GNU coreutils are under license GPL-3.0

TL;DR: none of these matters unless you want to dig deep into locale and ancient machines. Perhaps the only thing to look at is atexit()

There are a few function calls at the beginning of main, for example cp.c;
(note, what happens between _start and main is per standard library, that’s another story)

// Copyright (C) 1989-2025 Free Software Foundation, Inc.
// Written by Torbjörn Granlund, David MacKenzie, and Jim Meyering.

int
main (int argc, char **argv)
{
  // [SNIP] .. declare vairables
  initialize_main (&argc, &argv);
  set_program_name (argv[0]);
  setlocale (LC_ALL, "");
  bindtextdomain (PACKAGE, LOCALEDIR);
  textdomain (PACKAGE);

  // some calls this
  atexit (close_stdin);
  // some calls this
  initialize_exit_failure (SOME_ERR_ENUM);

  // [SNIP] .. deal with commandline options
  // [SNIP] .. and rest of the code
}

initialize_main : macro defined in system.h.. used for OS/2, which calls _wildcard and _response macros, of which I have no idea¹….
set_program_name, functoin defined in gnulib/lib/progname.{c,h}. Basically storing the program’s calling name (argv[0]) into a global variable (w/ absolute path). Also involves some temporary executable relating libtool…

setlocale set current locale (man 3 setlocale)

On  startup  of  the  main  program, the portable "C" locale is selected as
default.  A program may be made portable to all locales by calling:
setlocale(LC_ALL, "");

bindtextdomain / textdomain. Also locale related but that’s another story
atexit: man 3 atexit - register a function to be called at normal process termination
initialize_exit_failure .. set exit_failure to given status code (on error return)

weirdly I don’t even know where these are defined. This article says: If you want Unix-like wildcard expansion built into the program, use
```
int main (int argc, char *argv[]) { _wildcard (&argc, &argv); /* ... the program ... */ }
```
This should be done at the very beginning of main(), before ARGC and ARGV are used. See _wildcard() and _response()
yeah … I want to see but where??? ↩︎

dealing with commandline args

i@shrik3.com (SHRIK3) — Tue, 28 Jan 2025 13:44:20 +0100

TL;DR … parsing cmdline opts is pretty tedious with C
– and there is no really idiomatic way..

standard library

getopt from <unistd.h> for simple ones
argp from <argp.h> for complex ones
DIY: don’t

reads:

https://stackoverflow.com/questions/9642732/parsing-command-line-arguments-in-c

vim thoughts and rants

i@shrik3.com (SHRIK3) — Mon, 27 Jan 2025 10:10:13 +0100

§§§ priviously on shrik3’s 无能狂怒

text editor edits text!!!

repeat after me: T-E-X-T editor! What’s the fucking point of pulling out a CNC machine and call it “a better knife”? vi is a text editor, neovim is a text editor, lunar/astro/nvchad/* is not a fucking text editor. Just be honest with yourself. When you want a debugger, a languague server, a treesitter, a VCS integration, a rocket launcher … in your workflow, say it out loud that you want an IDE (just because you control the “I” of the “IDE” doesn’t change what it is.).

There is no elitism in this rant: I use whatever gets things done. The point is, arguing about the “the best text editor for programming” is just pointless.

§§§ when a text editor is less than a text editor

Now I’m thinking, what should be integrated into a text editor and what shouldn’t?

§§§ emojis

If you neovim you probably already know the name of Folke, developer of many beloved plugins.

While I do appreciate their works…. That consistent passion in abusing emojis in the docs… Well who am I to rant?

I mean, here https://github.com/folke/lazy.nvim
Every single line in the readme is led by an emoji. For me this is absolutely painful to read.

shells, bashrc and fish

i@shrik3.com (SHRIK3) — Sat, 25 Jan 2025 22:59:41 +0100

This post a about some sh/bash/fish configuration and, how to use fish together with bash.

§ the deal with sh

the original sh is Bourne-Shell
bash stands for Bourne-Shell-Again-Shell, a de-facto replacement to sh.

actually it’s linked to bash (or other shells like dash). Note that when bash and dash etc. are invoked with the sh name, the become more POSIX compliant¹.

$ ls -l $(which sh)

lrwxrwxrwx 1 root root /usr/bin/sh -> bash

The there are ports of the original Bourne-Shell (sh) e.g. v7sh

§ the deal with bashrc

– it’s a fuckign mess.

login shell: /etc/profile -> ~/.bash_profile -> ~/.bash_login -> ~/.profile
interactive non-login shell : /etc/bash.bashrc² -> ~/.bashrc
logout: /bash.bash_logout² -> ~/.bash_logout
non-interactive shell: inherit whatever the calling process has and nothing more.

what is system default doing i.e. /etc/bash.bashrc:

check window size per $DISPLAY
sets control sequence correctly for the prompt, depending on terminal type (screen, tmux, xterm, foot, …)
source completion commands

Note that when using bash as login shell, the ~/.bashrc is not sourced. For it to work, include the following line in ~/.bash_profile or ~/.profile

[[ -f ~/.bashrc ]] && . ~/.bashrc

man bash

When bash is invoked as an interactive login shell, or as a non-interactive
shell with the --login option, it first reads and executes commands from the
file /etc/profile, if that file exists.  After reading that file, it looks for
~/.bash_profile,  ~/.bash_login,  and ~/.profile, in that order, and reads and
executes commands from the first one that exists and is readable.  The
--noprofile option may be used when the shell is started to inhibit this
behavior.

When  an  interactive  login  shell exits, or a non-interactive login shell
executes the exit builtin command, bash reads and executes commands from the
file ~/.bash_logout, if it exists.

When an interactive shell that is not a login shell is started, bash reads and
executes commands from ~/.bashrc, if that file  exists. This may be inhibited by
using the --norc option.  The --rcfile file option will force bash to read and
execute commands from file in‐stead of ~/.bashrc.

refs:

https://wiki.archlinux.org/title/Bash#Configuration_files

§ fish shell (fuck)

I read on HN that you should set fish as terminal shell instead of login shell (i.e. through chsh). Pretty interesting idea. I’ll try that.

source the source

There are a few issues with fish shell.

it can’t explcitly source .bashrc. Meaning if you are using fish as login shell, it can not use what’s already there. Luckily my plan here is NOT TO use fish as login shell. But I still need a sanity check to make sure .bashrc is already sourced before fish is invoked.
in .bashrc
```
export BASHRC_SOURCED="yes"
```
in config.fish
```
if not set -q BASHRC_SOURCED
    echo "[WARNING!] .bashrc is not sourced, do not use fish as login shell!"
end
```
bash aliases are not inherited to fish, therefore you need to source it explicitly… (fuck)
in ~/.bash_aliases
```
alias abc=xyz
# your aliases
```
in ~/.bashrc
```
[[ -f ~/.bash_aliases ]] && . ~/.bash_aliases
```
in config.fish (perhaps check for file exists, but I won’t bother learning how fish scripting work)
```
source ~/.bash_aliases
```

wipe their builtin functions

have you ever wondered why your grep, ls and kill works differently than you expected? Or why your colors are wrong? Or why your aliases doesn’t work? That’s because fish is trying hard to give you wrappers to the very basic stuffs.

ls becomes a bloated cyptic script.
man becomes a bloated cryptic script.
kill receives (__fish_expand_pid_args $argv) which is another layer of cryptic indirection.
diff and grep receive --color=auto
… check fish_config -> functions for yourself.

Therefore you may want to wipe these builtins. In config.fish

# functions --erase grep
# functions --erase kill
# functions --erase ls
# functions --erase ll
# functions --erase la

Trivias: in case you don’t know, on linux, the commands like cd must be implemented into the shell, not as an external program or script. Every process has a working dir, tracked in task_struct.fs and is changed via the chdir syscall. In otherwords, a process can only change its own workding directory, therefore you can’t implement cd as a program.

§ epilogue

TAKE: While shells are supposed to implement their UNIX builtin functions (like. cd, pushd, popd, jobs … they are not supposed to change how programs work by default. When I call ls I expect to run the program. When I call kill I expect to run the program. I do not want your perks and a expecially do not want your smart-ass coloring.

TAKE: fish sucks, why use it then? – because UNIX eco system sucks more. I’m not hyperthymestic, I can’t remember how those programs are parameterized – and they are not defined in a conventional manner! I fucking need the completion and tooltips, period.

https://wiki.archlinux.org/title/Command-line_shell#POSIX_compliant ↩︎
this depends on the compilation flag.-DSYS_BASHRC or -DSYS_BASH_LOGOUT. This is per-distro. ↩︎ ↩︎

Fediverse: Small Instance Pipedream

i@shrik3.com (SHRIK3) — Fri, 24 Jan 2025 01:34:40 +0100

§ small-instance fedi pipedream

It’s often brought up that you should avoid mega instances such as mastodon.social and you should use small instances operated by people you trust, or, if possible, single-user instance.

While I do agree with that, how does this small-instance utopian scale?

[N to N] your home server needs to “broadcast” your statuses to all the servers that host your followers. If each of your N followers is on their own server then the request is multiplied by N.
[Storage] your home server needs to store copies of all the incoming statuses in the database and technically they are treated the in the same way as local ones. Operating small instance is growlingly gatekept as the network grows. For reference my 3-year-old instance of 100-ish users (among which only ~10 are active) now uses 34G data for database.
[Media] You need to store media (at least local uploads) as well. There is a tradeoff in remote content caching: if you turn it on you have increasing storage usage and bears the responsibility of data privacy. But if everyone turns it off then we are DDoSing each other because the remote content is fetched whenever it’s viewed.
[It Grows] the fediverse network works perfectly now but that’s when fediverse is still a niche. It’s a ever growing space and more people are joining it. The scalability of fediverse will be soon tested.
[Cannot Forget] it’s exponentially harder to erase data off the fediverse: if you, for whatever reason, need to delete something you posted, good luck with that because any federated instance may have a copy of that data and they don’t necessarily care about your deletion request. The more instances there are, the harder it becomes.
[Moderation] if everyone lives on their own instances the concept of “moderation” will no longer exist: “Moderation” means some selected actors filter contents for the other users, since you are the only user it’s simply a “mute list”
whitelisting is a thing, but that’s not what we really want. “wanna have whitelisted fedi network for a laugh? We had a tool for that since the USENET, it’s called a BBS”
[Accessibility] that fact is that only a minority of fedi users have the skill, time, resources and will to operate an instance. Even something as 傻瓜式 as a hosted service (such as commercial wordpress hosting) sets many people back because it’s not intuitive for non-techies to understand the basic concepts. Even if you give everyone an managed instance with via a single-click button, those lacking basic knowledge can’t really protect their data and identities from all sorts of pitfalls.
And I may argue that a managed instance is not your own instance. There are still people who have the privilege to see your data ¹.

on shared instances:

bigtechs track you and sell your data, but why would you trust individuals you never met instead? An instance admin could easily see all your private posts (even DMs); they could reset your password and impersonate you; they can as well sell your data and it’s even harder to sue them because small instances rarely has any legal entities and the are hosted all around the world where different digital laws apply. And this paranoia again leads to single-user instances, which makes other point more relevant.

on mega instances:

it’s out-of-scope for this post to talk about that. I’m only refraining this: mega instances are bad.

okay, now what?

TL;DR, I don’t know. If you know better I do want to hear.
Trust issue is not only with fediverse. Actually it’s a dead end if you dig.
Relays could reduce overheads in a small-instance network. But as a fediverse (pleroma) instance operator I still don’t believe in relays. Maybe my opinion will change in the future but for now moderation is such a pain when the “relayed” servers have different rule sets.
While I do hope for a world every one can be a cyber landlord, such fantasy is as far-fetched as communism.

what about nostr? (hot take alerts)

I was introduced to nostr, a even more progressively decentralized network. In theory you are not represented by an instance, but by your cryptographic keys – this is not a new concept, PGP has been there since…

While I’m intrigued by the protocol that allow you to totally control your online identity, I’m not yet convinced. The simple fact is:

you own your identity, but you don’t distribute the contents, the relays do.

The promise is that your content can’t be censored, the reality is that the relay operators can decide whether they like you, as well as whether they like other relays. The cencorship (or, moderation) model is not fundamentally different than typical fediverse. And “running your own relays / vendoring your own NIP-05 IDs” matches exactly “running your own fedi instance”

Compatibility with fediverse (as in ActivityPub based social network): so there are bridges. Joining a relay means that your identity is represented by the relay (TODO)
censorship & moderations (TODO)
repeating the point: your pubkey is not for a human to read, which means that
You need to pay to get a NIP-05 address. … Ah … then there comes blockchain companies??

NIP-05 enables a Nostr user to map their public key to a DNS-based internet identifier.
“but you are not limited to fediverse, you can carry you identity to any service if they support it” – yes, but how is that any different than using OAuth2?

My conclusion on nostr: at least for the time being, nostr is just a hacky implementation of the same fediverse idea.

you may argue that a cloud vendor is the same: they have control on the hardware and they are technically able to dump your data. But data privacy with major cloud providers is a long established thing. I assume those hosted service may be less bounded. But I may be wrong. ↩︎

quotes

i@shrik3.com (SHRIK3) — Fri, 24 Jan 2025 01:09:52 +0100

some random one-liners from the internet – for fun!

Right here is the hardest question in programming:
is this too much voodoo for our purposes?
— Terry Davis
With greate processing power comes greate responsibility.
— the hackerman
imagine a spinning ball, except that it’s not spinning …. and it’s not a ball
— someone youtube video explaining electron’s spin 2
a foreign student goes to a german mensa, from vegan and meat offers he chosed “and”¹.
— I saw this happening.
— “Welche Licenz?’
— “MIT” (ha, ha, ha, slow clap)
For those not in the know, PID stands for proportional, integral, derivative control. I’ll break it down:
P: if you’re not where you want to be, get there.
I: if you haven’t been where you want to be for a long time, get there faster
D: if you’re getting close to where you want to be, slow down.

PID demo, by Horizon 4 electronics, youtube
comment by warlax5658
If it moves, it’s biology, if it smells, it’s chemistry, if it doesn’t work, it’s physics.
Youtube comment found here
... Davidson is the most efficient way to convert fuel into noise without the side effect of horsepower.

The question was “Mit Fleisch oder mit Gemüse? (with meat or with vegatable?)”. He heared “meat (mit)” and answered “meat”. ↩︎

input output, file, pipe, redirections and parameters

i@shrik3.com (SHRIK3) — Thu, 23 Jan 2025 18:30:04 +0100

GO BACK

Fuck this cryptic syntax.

§ Redirection

example

#! /usr/bin/bash
echo_to_err() { printf "%s\n" "$*" >&2; }

echo "msg to stdout"
echo_to_err "msg to stderr"

console output is not standard output Typically, your shell would print both program stdout and stderr.

If you run ./example > hello.txt, the hello.txt would only contain msg to stdout and your console would only show msg to stderr

shut the fuck up
Redirect everything to black hole. note that you need to redirect stdout to file first, then redirect stderr to stdout[^order]

$ ./example > /dev/null 2>&1

ordering of redirect
in the last example you need to first redirect stdout to file then stderr to stdout. this post nicely explain why the ordering is like this.

In a nutshell: > is an asignment, not an arrow! e.g. with > file you asign file (rvalue) to 1 (lvalue), NOT point 1 to file.

> /dev/null   # 1 becomes `file`
2>&1          # 2 becomes value of 1 i.e. `file`
              # & is like $, marking a variable)

symbols

<   input redirection
<<  input redirection, here document
<<< input redirection, here string
>   output redirect, overwrite if targeting file
>>  output redirect, append if targeting file

redirect flle to program stdin:
    wc < file

duplicate the stream
command | tee <file> : Keep tty output and write to file (i.e. , do not redirect). In the following example both msg to stdout and msg to stderr are printed to tty; but only msg to stdout is written to log.txt

$ ./example | tee log.txt

redirect stderr to stdout
use 2>&1

$ ./example 2>&1 | tee log.txt

file descriptors:
0 for stdout, 1 for stdin, 2 for stderr

char devices

/dev/null: black hole, swallows whatever you give it without side effect. Useful for silencing program output. Unlike this provides no output if you read it.
/dev/zero: continuous stream of NULL, can be used to wipe a storage device with dd (if you know what you are doing…)
/proc/<PID>/fd/: file descriptors of process <PID> for normally both 0 and 1 are linked to /dev/tty* but redirecting things to these FDs may not work as you expected….
/dev/stdin -> /proc/self/fd/0
/dev/stdout -> /proc/self/fd/1
/dev/stderr -> /proc/self/fd/2: duplicated fds for the current process’s stdio

here string

$ COMMAND <<< $THING

Is (effectively) equivalent to

echo $THING | COMMAND

Where $THING is expanded and fed to stdin of COMMAND. However the later echo-pipe example essentially creates two processes (echo and COMMAND) and redirect one’s stdout to another’s stdin.

here document

$ COMMAND << EOF
    Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo
    ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis
    parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec,
    pellentesque eu,
EOF

Example. print here documnet to a file

cat << EOF >> output.tex
this
is
a
test
EOF

§ Pipe & Socket & term // TODO

// TODO //

§ Parameters

NOTE: this one is not about bash scripting, i.e. I won’t include stuffs like “how can I parse commandline options”

double minus --
marks the end of command options. After which only positional arguments are accecpted. For example if you have a file called -v, cat -v won’t work because -v is treated as an argument to cat. Instead do cat -- -v

single minus -
It depends of commands. But most intriguingly: use with a pipe, to use a program’s output as another’s parameter.

$ echo "hello" | rm - equals
$ rm hello or
$ rm $(echo "hello")
Another useful example is
$ pacman -Qtdq | sudo pacman -Rns - which finds and kill the orphans (evil pun intended)

§ Privilege

redirects are performed by the shell. Sudo gives privelege to the annoted program, not to the shell. e.g. the following won’t work even with sudo

$ sudo echo 0 > /proc/sys/kernel/sysrq
warning: An error occurred while redirecting file '/proc/sys/kernel/sysrq'
open: Permission denied

wordaround with tee:

$ echo 0 | sudo tee /proc/sys/kernel/sysrq

§ Parallelization?

Just an example how you may make things faster with a redirect.

Say you have a program like this: you produce a high throughput of data, compress it (via gzip/zlib stream) and store it to disk. Say, the get_data() is more busy than the zlib compression.

1
2
3

while (1) {
    gz_stream << get_data();
}

Instead of

my_program > output.gz

You could use a simple uncomressed stream in the program and do the compression externally.

mkfifo temp.pipe
myprogram > temp.pipe && \
gzip -cf1 <temp.pipe >output.gz

For cache utilization, your system scheduler may heuristically run myprogram and gzip on the same CPU. To force affinity:

taskset -c 0 myprogram > temp.pipe & \
taskset -c 1 gzip -cf1 < output.gz

But it really depends on your data throughput vs computation leverage. Sharing data between CPUs comes with a cost (you would certainly hit L3). The above example may give you little to no gain.

§ what do you mean “foreground” and “background”

refs

here string: https://tldp.org/LDP/abs/html/x17837.html
more on how here string works vs. pipe: https://unix.stackexchange.com/a/219805
bash redirections, GNU: https://www.gnu.org/software/bash/manual/html_node/Redirections.html

time to write neovim plugins

i@shrik3.com (SHRIK3) — Thu, 23 Jan 2025 18:04:55 +0100

Finally it’s time I make (neo)vim plugins myself. When I have the time, of course…. This is atm just a scratchpad of ideas.

Some ideas:

hugo helper: typically you use the hugo new command to create a new page document. It will use your predefined archtype (or default settings) to create a frontmatter. Doing this manually is a pain, e.g. for a proper RFC 3339 date string you may need :r! date --rfc-3339=seconds. There are more on my wishlist but now it would be nice to have a wrapper that simply call hugo to parse the archtype and insert the parsed archtype template for me (not like hugo new). Unluckily hugo doesn’t seem to provide an option to hugo new to print to stdout… I may need to hack something together.. (like, with a temp file?)
bundle plugins for basic extensions. There are so many seemingly trivial stuffs that I have to achieve via some plugins … one plugin for x, one plugin for y … And some of them are just overkills. I want a simple plugin that bundle all these trivial needs with simple toggles.
- just fucking delete : if you don’t know, all vim deleteion commands will overwrite your clip-board register¹. I need a command that simple deletes.
- fucking identations: I want hard tabs for identations and soft tabs for alignments. There are scripts floating around but I need a better wrapper.
- pair brackets with no bullshit : this is a very basic need, I have no idea why vim doesn’t have it by default. (And existing plugins seem too heavy for what they do)

see my rants ↩︎

serial tty

i@shrik3.com (SHRIK3) — Thu, 23 Jan 2025 11:21:53 +0100

UART: Universal Asynchronous Receiver / Transmitterund
stty (coreutils): change and print terminal line settings. e.g. sudo stty -F /dev/ttyS0 -a to show all settings

default port and IRQ config for serials (depends on the driver)

$ sudo cat /proc/tty/driver/serial

/dev/   Name    IO Port     UART    IRQ

ttyS0   COM1    0x3F8       16550A  4
ttyS1   COM2    0x2F8               3
ttyS2   COM3    0x3E8               4
ttyS3           0x2E8               3
ttyS4           0xE080      16550A  19

getting tty configs (i.e. protocol for communication…)

$ sudo stty -F /dev/ttyS0 -a
speed 9600 baud; rows 0; columns 0; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>; eol2 = <undef>; swtch = <undef>;
start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V; discard = ^O; min = 1; time = 0;
-parenb -parodd -cmspar cs8 hupcl -cstopb cread clocal -crtscts
-ignbrk -brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff -iuclc -ixany -imaxbel
-iutf8
opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke -flusho
-extproc

Refs

snippets, quick facts and takeaways

i@shrik3.com (SHRIK3) — Wed, 22 Jan 2025 10:43:29 +0100

COPYRIGHT NOTICE: text and code copied or derived from git commit message, mailinglist, or codebase are subject to the linux kernel licensing rules

§§§ (x86) cause delay by IO to 0x80

this article says “to output any byte to the port 0x80 should delay exactly 1 microsecond”. But I can’t find a reference yet.

/arch/x86/boot/boot.h

static inline void io_delay(void)
{
	const u16 DELAY_PORT = 0x80;
	outb(0, DELAY_PORT);
}

More: https://stackoverflow.com/questions/6793899/what-does-the-0x80-port-address-connect-to

Booting Process (WIP)

i@shrik3.com (SHRIK3) — Wed, 22 Jan 2025 10:04:08 +0100

COPYRIGHT NOTICE: text and code copied or derived from git commit message, mailinglist, or codebase are subject to the linux kernel licensing rules

§ after the bootloader (grub)

kernel entry point

arch/x86/boot/header.S

calll   main

arch/x86/boot/main.c

void main(void)
{
    init_default_io_ops();

    /* First, copy the boot header into the "zeropage" */
    copy_boot_params();

    /* Initialize the early-boot console */
    console_init();
    if (cmdline_find_option_bool("debug"))
        puts("early console in setup code\n");

    /* End of heap check */
    init_heap();

    /* Make sure we have all the proper CPU support */
    if (validate_cpu()) {
        puts("Unable to boot - please use a kernel appropriate "
             "for your CPU.\n");
        die();
    }

    /* Tell the BIOS what CPU mode we intend to run in. */
    set_bios_mode();

    /* Detect memory layout */
    detect_memory();

    /* Set keyboard repeat rate (why?) and query the lock flags */
    keyboard_init();

    /* Query Intel SpeedStep (IST) information */
    query_ist();

    /* Query APM information */
#if defined(CONFIG_APM) || defined(CONFIG_APM_MODULE)
    query_apm_bios();
#endif

    /* Query EDD information */
#if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
    query_edd();
#endif

    /* Set the video mode */
    set_video();

    /* Do the last things and invoke protected mode */
    go_to_protected_mode();
}

go to 32 bit

void go_to_protected_mode(void)
{
    /* Hook before leaving real mode, also disables interrupts */
    realmode_switch_hook();

    /* Enable the A20 gate */
    if (enable_a20()) {
        puts("A20 gate not responding, unable to boot...\n");
        die();
    }

    /* Reset coprocessor (IGNNE#) */
    reset_coprocessor();

    /* Mask all interrupts in the PIC */
    mask_all_interrupts();

    /* Actual transition to protected mode... */
    setup_idt();
    setup_gdt();
    protected_mode_jump(boot_params.hdr.code32_start,
                (u32)&boot_params + (ds() << 4));
}

32 bit code entry point

https://elixir.bootlin.com/linux/v6.6.67/source/arch/x86/boot/header.S#L275


code32_start:               # here loaders can put a different
                            # start address for 32-bit code.
        .long   0x100000    # 0x100000 = default for big kernel

§ readings

All Stages of Linux Booting Process Explained, nu11secur1ty,
https://github.com/nu11secur1ty/All-Stages-of-Linux-Booting-Process-Architecture
Kernel booting process, 0xAX
https://github.com/0xAX/linux-insides/blob/master/Booting/linux-bootstrap-1.md
the linux/x86 boot protocol, https://www.kernel.org/doc/Documentation/x86/boot.txt

ongoing: Designing Freedom (Stafford Beer)

i@shrik3.com (SHRIK3) — Tue, 21 Jan 2025 18:27:07 +0100

came across this video on youtube: Designing Freedom: The Disregarded Tools of Modern Man | Stafford Beer

“Six radio broadcasts given in the autumn of 1973 as the thirteenth series of Massey Lectures which were established in 1961 bythe Canadian Broadcasting Corporation to enable distinguished authorities in fields of general interest and importance to present the results of original study or research.”

Contents:

The Real Thread to “All We Hold Most Dear”
The Disregarded Tools of Modern Man
A Liberty Machine in Prototype
Science in the Service of Man
The Future That Can Be Demanded Now
The Free Man in the Cybernetic World

Resources:

hugo recursive listings

i@shrik3.com (SHRIK3) — Tue, 21 Jan 2025 16:19:29 +0100

My blog has a tree style listing for pages (screenshot below). I managed to do this after many tries .. there are pretty much zero resources on the internet regarding how to do this properly.

§ doc structure

First thing is that you need to have your content directory structure properlly. The respective dir structure for the screenshot below is:

TL;DR: if you want a directory to become a logical section, it has to directly contain _index.md. (directories directly under root dir i.e. /content/ are selbständlig sections).

content/notes/
├── _index.md
├── misc/
│   ├── article1.md
│   ├── article2.md
│   └── _index.md
├── tooling/
│   ├── article3.md
│   ├── article4.md
│   └── _index.md
├── linux/
    ├── _index.md
    ├── article5.md
    ├── article6.md
    └── tooltips/
        ├── article7.md
        └── _index.md

For a page to be treated as a “Node” (or, “Section”), it has to contain _index.md (or other supported content formats of the same name)
A “section” could be a page at the same time. The page content is that of _index.md. Think about a tree of pages, some pages are nodes and some are leaves. These node pages are not of .RegularPages

For example, if content/notes/linux has do direct _index.md, the above structure is equilevant to:

content/notes/
├── _index.md
├── misc/
│   ├── article1.md
│   ├── article2.md
│   └── _index.md
├── tooling/
│   ├── article3.md
│   ├── article4.md
│   └── _index.md
├── article5.md
├── article6.md
└── tooltips/
    ├── article7.md
    └── _index.md

Well, it’s not completelely the same, for example if you don’t specify a url parameter for each page under linux/, the /linux will become part of the url. e.g. in both cases the url to article7 is.

/notes/linux/tooltips/article7

In other words, the default url is derived from the file system structure, not the logical relationships. (I’m pretty sure there are ways to have different url scehemes but I’m not digging into it)

§ recursively render a tree

TL;DR: you can check the page parameter (method) .IsNode ¹. If it is a node, dive into it by getting its .Pages, otherwise list it as normal page.

Code /layouts/_default/list.html

<!DOCTYPE html>
<html>
{{ partial "head.html" . }}
<body>
<main>

<article> {{.Content} </article>

{{ partial "fs_style_page_list.html" .}}

</main></body></html>

Code /layouts/partials/fs_style_page_list.html
We can use the first .Ancestors to have a “parent dir” url.

{{with .Path}} <h2>index of {{.}}/</h2> {{end}}

<table><tbody>

{{with (index  .Ancestors 0)}}
    <tr><td><a href="{{ .Permalink }}"><strong>../</strong></a></td></tr> {{end}}

{{range .Pages}}
    {{partial "internal_fs_node_recursive.html" (dict "context" . "depth" 0)}}
{{end}}

</tbody></table>

Code /layouts/partials/internal_fs_node_recursive.html
note that we increment the depth counter with every recursive call

{{$depth := .depth}}
{{if .context.IsNode}}
    <tr><td>
            {{partial "internal_fs_indent.html" .}}
            <a href="{{ .context.Permalink }}">{{ .context.Title }}/</a>
    </td></tr>
    {{range .context.Pages}}
    {{partial "internal_fs_node_recursive.html" (dict "context" . "depth" (add $depth  1))}}
    {{end}}
{{else}}
    <tr class="alt_color">
    <td>
            {{partial "internal_fs_indent.html" .}}
            <a href="{{ .context.Permalink }}">{{ .context.Title }}</a>
    </td>
    <td>{{.context.Date.Format "02-Jan-2006" }}</td>
    </tr>
{{end}}

Code (helper): /layouts/partials/internal_fs_indent.html
add leading indentations w.r.t the directory depth

1
2
3

<span class="unselectable">
{{range (seq .depth)}} |&nbsp; {{end}}
</span>

https://gohugo.io/methods/page/isnode/ ↩︎

pack struct file for cacheline optimizations

i@shrik3.com (SHRIK3) — Tue, 21 Jan 2025 12:13:18 +0100

COPYRIGHT NOTICE: text and code copied or derived from git commit message, mailinglist, or codebase are subject to the linux kernel licensing rules

I reading struct file related source code and … realized that my copy of source code was very different than the mainline kernel code (… well this was weird to me, like, who has the balls to change a data structure as important as struct file so dramatically? … anyways I found this recent patch (merged Aug. 2024). Which reordered the struct members in the name of cache line performance.

Anyways it is to

shrunk struct file to 192 bytes aka 3 cachelines reorder struct file to not leave any holes or have members cross cachelines.

It’s said to boost performance but they didn’t say how much.

Take away?

don’t offset into an data structure because this kind of change could happen. You may know what your are doing but others don’t know your implements of hacks when change the code. Or more generally, don’t assume internal data layout (padding, aligning, ordering…) of a struct.
it turns out that you could out-smart the compiler!

Original patch & discussions:

https://lore.kernel.org/all/20240824-peinigen-hocken-7384b977c643@brauner/

commit c0390d541128e8820af8177a572d9d87ff68a3bb
Author: Christian Brauner <brauner@kernel.org>
Date:   Fri Aug 23 21:06:58 2024 +0200

    fs: pack struct file
    
    Now that we shrunk struct file to 192 bytes aka 3 cachelines reorder
    struct file to not leave any holes or have members cross cachelines.
    
    Add a short comment to each of the fields and mark the cachelines.
    It's possible that we may have to tweak this based on profiling in the
    future. So far I had Jens test this comparing io_uring with non-fixed
    and fixed files and it improved performance. The layout is a combination
    of Jens' and my changes.
    
    Link: https: //lore.kernel.org/r/20240824-peinigen-hocken-7384b977c643@brauner
    Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 095a956aeb29..af8bbd4eeb3a 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -987,52 +987,63 @@ static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
 		index <  ra->start + ra->size);
 }
 
-/*
- * f_{lock,count,pos_lock} members can be highly contended and share
- * the same cacheline. f_{lock,mode} are very frequently used together
- * and so share the same cacheline as well. The read-mostly
- * f_{path,inode,op} are kept on a separate cacheline.
+/**
+ * struct file - Represents a file
+ * @f_count: reference count
+ * @f_lock: Protects f_ep, f_flags. Must not be taken from IRQ context.
+ * @f_mode: FMODE_* flags often used in hotpaths
+ * @f_op: file operations
+ * @f_mapping: Contents of a cacheable, mappable object.
+ * @private_data: filesystem or driver specific data
+ * @f_inode: cached inode
+ * @f_flags: file flags
+ * @f_iocb_flags: iocb flags
+ * @f_cred: stashed credentials of creator/opener
+ * @f_path: path of the file
+ * @f_pos_lock: lock protecting file position
+ * @f_pos: file position
+ * @f_version: file version
+ * @f_security: LSM security context of this file
+ * @f_owner: file owner
+ * @f_wb_err: writeback error
+ * @f_sb_err: per sb writeback errors
+ * @f_ep: link of all epoll hooks for this file
+ * @f_task_work: task work entry point
+ * @f_llist: work queue entrypoint
+ * @f_ra: file's readahead state
  */
 struct file {
-	union {
-		/* fput() uses task work when closing and freeing file (default). */
-		struct callback_head 	f_task_work;
-		/* fput() must use workqueue (most kernel threads). */
-		struct llist_node	f_llist;
-		/* Invalid after last fput(). */
-		struct file_ra_state	f_ra;
-	};
-	/*
-	 * Protects f_ep, f_flags.
-	 * Must not be taken from IRQ context.
-	 */
-	spinlock_t		f_lock;
-	fmode_t			f_mode;
-	atomic_long_t		f_count;
-	struct mutex		f_pos_lock;
-	loff_t			f_pos;
-	unsigned int		f_flags;
-	unsigned int 		f_iocb_flags;
-	struct fown_struct	*f_owner;
-	const struct cred	*f_cred;
-	struct path		f_path;
-	struct inode		*f_inode;	/* cached value */
+	atomic_long_t			f_count;
+	spinlock_t			f_lock;
+	fmode_t				f_mode;
 	const struct file_operations	*f_op;
-
-	u64			f_version;
+	struct address_space		*f_mapping;
+	void				*private_data;
+	struct inode			*f_inode;
+	unsigned int			f_flags;
+	unsigned int			f_iocb_flags;
+	const struct cred		*f_cred;
+	/* --- cacheline 1 boundary (64 bytes) --- */
+	struct path			f_path;
+	struct mutex			f_pos_lock;
+	loff_t				f_pos;
+	u64				f_version;
+	/* --- cacheline 2 boundary (128 bytes) --- */
 #ifdef CONFIG_SECURITY
-	void			*f_security;
+	void				*f_security;
 #endif
-	/* needed for tty driver, and maybe others */
-	void			*private_data;
-
+	struct fown_struct		*f_owner;
+	errseq_t			f_wb_err;
+	errseq_t			f_sb_err;
 #ifdef CONFIG_EPOLL
-	/* Used by fs/eventpoll.c to link all the hooks to this file */
-	struct hlist_head	*f_ep;
-#endif /* #ifdef CONFIG_EPOLL */
-	struct address_space	*f_mapping;
-	errseq_t		f_wb_err;
-	errseq_t		f_sb_err; /* for syncfs */
+	struct hlist_head		*f_ep;
+#endif
+	union {
+		struct callback_head	f_task_work;
+		struct llist_node	f_llist;
+		struct file_ra_state	f_ra;
+	};
+	/* --- cacheline 3 boundary (192 bytes) --- */
 } __randomize_layout
   __attribute__((aligned(4)));	/* lest something weird decides that 2 is OK */

linux file permissions

i@shrik3.com (SHRIK3) — Tue, 21 Jan 2025 11:49:22 +0100

§ chmod

chmod [ugoa] [-+=] [rwxXst]

users
u : the user who owns it
g : user in the files' group
o : other users not in the file's group
a : all uers.

perms
rwx : read (4), write (2), execute (1)

§ Other than rwx

setuid / setgid : whether the program can set its user id / group id. If the program is a script then this bit is ignored (for security reasons)
sticky bit:

Filemode defs¹

#include <sys/stat.h>
int fchmod(int fildes, mode_t mode);

mode bits: (man 2 fchmod)

S_ISUID  (04000)
    set-user-ID (set process effective user ID on execve(2))

S_ISGID  (02000)
    set-group-ID  (set  process  effective  group  ID on execve(2); mandatory
    locking, as described in fcntl(2); take a new file's group from parent
    directory, as described in chown(2) and mkdir(2))

S_ISVTX  (01000)
    sticky bit (restricted deletion flag, as described in unlink(2))

S_IRUSR  (00400)
     read by owner

S_IWUSR  (00200)
    write by owner

S_IXUSR  (00100)
    execute/search by owner ("search" applies for directories, and means that
    entries within the directory can be accessed)

S_IRGRP  (00040)
    read by group

S_IWGRP  (00020)
    write by group

S_IXGRP  (00010)
    execute/search by group

S_IROTH  (00004)
    read by others

S_IWOTH  (00002)
    write by others

S_IXOTH  (00001)
    execute/search by others

struct file

struct file {
    atomic_long_t                   f_count;
    spinlock_t                      f_lock;
    fmode_t                         f_mode;
    const struct file_operations   *f_op;
    struct address_space           *f_mapping;
    void                           *private_data;
    struct inode                   *f_inode;
    unsigned int                    f_flags;
    unsigned int                    f_iocb_flags;
    const struct cred              *f_cred;
    struct path                     f_path;
    union {
        // regular files (with FMODE_ATOMIC_POS) and directories
        struct mutex f_pos_lock;
        // pipes
        u64 f_pipe;
    };
    loff_t                          f_pos;
    void                           *f_security; // ifdef CONFIG_SECURITY
    struct fown_struct              *f_owner;
    errseq_t                        f_wb_err;
    errseq_t                        f_sb_err;
    struct hlist_head              *f_ep;       // ifdef CONFIG_EPOLL

#endif
    union {
        struct callback_head    f_task_work;
        struct llist_node   f_llist;
        struct file_ra_state    f_ra;
        freeptr_t       f_freeptr;
    };
    /* --- cacheline 3 boundary (192 bytes) --- */
}

§ refs:

https://wiki.archlinux.org/title/File_permissions_and_attributes

File mode bits: https://elixir.bootlin.com/linux/v6.5/source/include/uapi/linux/stat.h#L29 ↩︎

hugo weird list

i@shrik3.com (SHRIK3) — Mon, 20 Jan 2025 04:33:10 +0200

this is just a unused listing style. keeping it here because I spent quite some time on it. (Quite some hackary…)

The idea is that a post e.g. /content/post/foo/bar/that.md

should be renered into

<span>::post::foo::bar::<<a href="link">>that</a></span>

in this case pages should be sorted w/ their path (as in file path).

partial namespace-list-plain.html

<pre>
{{- range .}}
{{- $cat := split .Path "/" }}
{{- if gt (len $cat) 1 }}
{{- $cat := after 2 $cat }}
{{- end}}
{{- $cat  = first (sub (len $cat) 1) $cat}}
{{- $prefix := delimit $cat "::"}}
{{$prefix}}::<a href="{{ .Permalink }}">{{ .Title }} </a>
{{- end }}
</pre>

my blog deploy script

i@shrik3.com (SHRIK3) — Sun, 19 Jan 2025 14:50:51 +0100

#!/usr/bin/sh

bold=$(tput bold)
normal=$(tput sgr0)

blog_root=/home/shrik3/docs/blog
site_local=$blog_root/site
# trailing slash is necessary for rsync
webroot_remote=shrik3@shrik3.com:/srv/www/blog/

# for performance, limit the max number of URLs to pass to openring
limit=6
openring_in=~/docs/blog/webring_in.html
openring_out=~/docs/blog/site/layouts/partials/webring.html
webring_src="https://raw.githubusercontent.com/XXIIVV/webring/main/index.html"

# adhoc pages on wth.moe
vnoid_root=$blog_root/vnoid_home
vnoid_remote=shrik3@vnoid:~/www

sync_vnoid() {
    pushd $vnoid_root
    ./gen.sh
    rsync -avh -og --chown=shrik3:http --info=progress2 \
        --info=name0 --update --delete-after \
        $vnoid_root/ $vnoid_remote/
    popd
}

print_help(){
    echo "usage":
    echo "without parameters: render the blog as normal"
    echo "[optional]"
    echo "      --fedi      include fedi timeline"
    echo "      --webring   include webring"
    echo "      --misc      include static files"
    echo "      --all       include all options"
}

pull_timeline(){
    echo "${bold} Fetching Timeline from fedi... ${normal}"
    cd $blog_root/timelinebot
    ./timelinebot.py
}

# parse webring index.html into openring parameters
# | grep -Po        # extract pattern from html
# | shuf | head -n  # randomize and select n of them
# | sed             # prefix each html with '-s'
pull_webring(){
    echo "${bold} Pulling webring... ${normal}"
    rss_list=$(curl $webring_src | grep -Po '.*href="\K.*(?=" class="rss")' | shuf | head -$limit | sed -e 's/^/-s /')
    # rss_list=$(curl $webring_src | grep -Po '.*href="\K.*(?=" class="rss")' | shuf | sed -e 's/^/-s /')
    openring $rss_list < $openring_in > $openring_out
}


sync_files(){
    echo "${bold} Sync static files ... ${normal}"
    cd $blog_root
    ./syncmisc
}


while [[ $# -gt 0 ]]; do
    case $1 in
        --vnoid)
            sync_vnoid
            exit 0
            ;;
        --fedi)
            pull_timeline
            shift 1;
            ;;
        --webring)
            pull_webring
            shift 1;
            ;;
        --misc)
            gpg --export --armor --export-options export-minimal $GPGKEY > $blog_root/misc/gpg.asc
            sync_files
            shift 1;
            ;;
        -*|--*)
            print_help
            exit 1
            ;;
        *)
            print_help
            exit 1
            ;;
    esac
done


# render blog
cd $site_local
echo "${bold} Rendering blog... ${normal}"

# update gpg pubkey
echo "${bold} Appending key $GPGKEY... ${normal}"
gpg --export --armor --export-options export-minimal $GPGKEY > $site_local/layouts/partials/pubkey.asc

# dump a git log
git log --format=reference | head > $site_local/layouts/partials/gitlog.asc

# the render
hugo --ignoreCache
# copy key into public dir
cp $site_local/layouts/partials/pubkey.asc $site_local/public/gpg.asc

# sync files
echo "${bold} Sync blog to remote server... ${normal}"
rsync -avh -og --chown=http:http --info=progress2 --info=name0 --update --delete-after $site_local/public/ $webroot_remote

# Reminder
echo
echo "${bold} Remember to commit the changes and push to remote repo ${normal}"

all pages

i@shrik3.com (SHRIK3) — Sun, 19 Jan 2025 00:53:20 +0100

§ everything.

(perhaps I should’ve sort by name/path instead of date…)

index of /

Volatile/ │ checklist for learning programming language 25-Feb-2026 │ quotes 24-Jan-2025 │ request for comment 12-Nov-2024 │ footguns 04-Nov-2024 │ random pieces 26-Oct-2024 │ Wiedergabe - Musik Review 29-Aug-2024 │ Take 19-Aug-2024 │ 我该怎么用中文说.... 05-Aug-2024 │ 避免部分互联网内容 (ongoing) 22-Jul-2024 │ rants and shitposting 27-Jun-2024 │ [R18G] [CONTENT WARNING] code gore 10-May-2024 │ fiction, illusion and dream 30-Apr-2024 │ Travels bloody travels 07-Apr-2024 │ System Maintenance Log 05-Apr-2024 │ Pinned: stuffs that I keep googling again and again and again... 30-Nov-2023 │ DON'T FORGET, DON'T FORGIVE 21-Oct-2022 │ Bookmarks 07-Jun-2020 │ TIL: quick facts I learned 01-Jan-0001 paper reading/ │ The Nucleus of a Multiprogramming System 21-Oct-2025 Post/ │ Nix(OS) notes/ │ │ nix 01 - Nix subsystem for arch 03-Aug-2025 │ box drawing characters 18-May-2025 │ archived/ │ │ hugo weird list 20-Jan-2025 │ │ Blog visitor counter 01-May-2022 │ │ 如何用区块链合约做一个赌博应用？ 01-Jan-1970 │ │ 微博模拟登陆研究 01-Jan-1970 │ btw, I use arch/ │ │ archlinux setup + LUKS + LVM 22-Aug-2025 │ │ selfhosted AUR repo 04-Dec-2024 │ │ Installing Archlinux on removable media 22-Jun-2020 │ │ archlinux setup no bullshit 04-Jun-2020 │ │ [DEPRECATED] 一些archlinux的配置文件 11-Jul-2019 │ │ [DEPRECATED] archlinux使用贴士 01-Jan-1970 │ fun/ │ │ STOP USING(DOING) NERD FONTS 26-Feb-2024 │ │ Human as runtime 05-Oct-2023 │ │ western numbering is unfit for computer science, embrace the oriental 30-Sep-2023 │ hugo/ │ │ hugo recursive listings 21-Jan-2025 │ │ hugo license helpers 08-Oct-2024 │ │ pure fucking plaintext 08-Oct-2024 │ │ No bullshit hugo blog 21-Apr-2024 │ │ A Static Art Gallery with Hugo 29-Mar-2024 │ │ Hello html 24-Mar-2024 │ │ Comment system on a static site without javascript??? 06-Oct-2023 │ │ Add katex support to Hugo 29-May-2020 │ humachine/ │ │ FUCK YOUR MBTI BULLSHIT 10-Mar-2024 │ │ The media exploits ADHD (WIP // DRAFT) 15-Jan-2024 │ │ reflections on generative AIs 12-Jan-2024 │ │ Der Untergang des Wissens... 31-Jan-2023 │ prog/ │ │ C syntax is bad for regex 03-Jan-2024 │ │ Git or not git ... lessons learned (WIP) 13-Dec-2023 │ │ Binary Hacks - on inspecting a binary (ELF) 16-Oct-2023 │ │ End the holy war between space and tab indentation... 13-Oct-2023 │ │ Cursed C - snippets from Expert C Programming 04-Oct-2023 │ │ A simple kernel module 12-Jul-2020 │ pseudo/ │ │ Colors - It's more complicated than you think 07-May-2022 │ │ 语言的数量 13-Feb-2021 │ │ Das Wortproblem und Berechnungsmodell 16-Nov-2020 │ │ Word problem(Decision Problem), Complexity and computing models 16-Nov-2020 │ │ P,NP,NP-Hard and NP-Complete 16-Nov-2020 │ │ Stellenwertsystemen, Konvertierungen und Genauigkeit 11-Nov-2020 │ │ How RSA works 03-Jun-2020 │ scripts/ │ │ no bullshit code explorer 28-Jan-2025 │ │ my blog deploy script 19-Jan-2025 │ │ Text to speech in (neo)vim... 12-Oct-2023 │ │ Tomato clock! 07-Oct-2023 │ │ trivial spotify script.. 01-Feb-2023 │ │ switch vim buffers 26-Jan-2021 │ │ NASA's astronomy picture of the day 29-May-2020 │ sys/ │ │ Memory Jargons 22-Jul-2025 │ │ how fast are things in Linux (WIP) 04-Dec-2024 │ │ SysV ABI (AMD64) 23-Sep-2024 │ │ // DRAFT // The archtecture terminimology madness 25-Feb-2024 │ │ ELF, symbol table, and dynamic linking (WIP) 16-Feb-2024 │ │ How much Page Tables / PTEs are needed for xyz amount of memory? 29-Jan-2024 │ │ Chinese translations of computer terminologies (WIP) 06-Dec-2023 │ │ (WIP) Enclave Schizophrenia - What's TEE identity in Attestation? 03-May-2023 │ │ [WIP] send to stdin per PID 01-Feb-2023 │ │ OS notes 03-Feb-2021 │ │ osc/ │ │ │ CGA显示 25-Apr-2022 │ userland/ │ │ enabling sysrq 03-Feb-2025 │ │ replace GnuPG with age and signify 29-Jan-2025 │ │ ANSI escape code and OSC (terminal) 29-Jan-2025 │ │ shells, bashrc and fish 25-Jan-2025 │ │ Tile Split Tile Split Tile (rants) 14-Oct-2023 │ │ set up SSH tunnel for machines behind NAT 03-Oct-2023 │ │ Debian x VirtualBox Image checklist 04-Apr-2023 │ │ The cursed way to use a neovim-IDE on the CLOUD 12-Jan-2023 │ │ postgresql upgrade 24-Apr-2022 │ │ Make screenshare work in wayland 25-Nov-2021 │ │ xmonad Experience + i3-like config 20-May-2021 │ │ nvidia-xrun solution on hybrid graphic + tearing free 18-Nov-2020 │ │ Raspberry Pi as printing/file server 22-Jul-2020 │ │ bundle multiple ssh operations in scripts 24-May-2020 │ │ 有关UUID 12-Jul-2019 │ vim/ │ │ vim thoughts and rants 27-Jan-2025 │ │ time to write neovim plugins 23-Jan-2025 │ │ previously on neovim 21-Nov-2024 │ │ schnitzel.nvim : my neovim config 27-Nov-2023 │ │ Friendship ended with Packer 22-Sep-2023 │ │ Notes on (neo)vim 18-Nov-2022 │ │ vim tricks 17-Nov-2022 │ │ A (neo)vim IDE setup for C/C++, that just works 18-Apr-2022 │ │ Vim tab&buffer confusion 30-May-2020 │ www/ │ │ Fediverse: Small Instance Pipedream 24-Jan-2025 │ │ totally paranoid WWW guidelines 17-Jan-2025 │ │ The Fucking Web 06-May-2024 │ │ openring + webring, build a suckless web 07-Dec-2023 │ │ JS or no JS, that's a problem - towards a ZERO JS blog 07-Oct-2023 │ │ now on fediverse(pleroma)! 21-Jun-2021 │ │ Build your own search Engine 11-Jun-2020 Root/ │ test 28-Jul-2025 │ site map 10-Feb-2025 │ all pages 19-Jan-2025 │ Comm 19-Jan-2025 │ Add your link // 添加友链 26-Aug-2024 │ Comments on static blogs - the right way 03-Dec-2023 │ Copying 15-Oct-2023 │ Privacy and Data Collection 09-Oct-2023 │ About 07-Jun-2020 │ PubKey 07-Jun-2020 │ 谁是 shrik3 07-Jun-2020 IRL everyday stuffs/ │ scams 28-Jun-2025 │ Wissen führen! 12-Jun-2025 │ can I survive a month with 100 Euros for food? 12-Jun-2025 │ Kunststoff 30-Jan-2025 │ Koffein 14-Sep-2024 Readings/ │ ongoing: Designing Freedom (Stafford Beer) 21-Jan-2025 │ ongoing: Interpretation and Overinterpretation (Umberto Eco) 22-Oct-2024 timeline/ log/ │ I don't want to speak to ... 26-Mar-2024 │ WIP? WIP! 13-Oct-2023 │ Live_in 23-May-2023 │ Deconstruct 10-Mar-2022 │ Shells 29-Nov-2021 │ 配乐很好听的动漫 11-May-2021 │ Perfection at the price of humanity 18-Apr-2021 │ 啸叫 13-Apr-2021 │ Christmas trees are stupid 13-Apr-2021 │ 记一次删库 06-Apr-2021 │ 垃圾清理 02-Feb-2021 │ 一点体会 11-Jan-2021 │ 自动机 01-Dec-2020 │ Fri. Downtime 06-Aug-2020 │ A SIMPLE RULE 03-Jun-2020 │ 烤布丁与薄饼 08-Aug-2019 │ 土豆浓汤菜谱 04-Aug-2019 │ THIS IS A DUMPSTER OF TOXICITY 09-Jul-2019 │ Just Random 01-Jun-2019 bits/ │ bits 0x55 - CW 9 - 26, 2025 27-Feb-2025 │ bits 0x54 - Week 35~END 2024 03-Sep-2024 │ bits 0x53 - Week 28~35, 2024 11-Jul-2024 │ bits 0x52 - Week 17~27, 2024 [VOID] 03-Jul-2024 │ bits 0x51 - Calender Week 17, 2024 22-Apr-2024 │ bits 0x50 - Calender Week 16, 2024 16-Apr-2024 │ bits 0x49 - Calender Week 15, 2024 08-Apr-2024 │ bits 0x48 - Calender Week 14, 2024 03-Apr-2024 │ bits 0x47 - Calender Week 13, 2024 24-Mar-2024 │ bits 0x46 - Calender Week 12, 2024 18-Mar-2024 │ bits 0x45 - Calender Week 11, 2024 14-Mar-2024 │ bits 0x44 - Calender Week 10, 2024 10-Mar-2024 │ bits 0x43 - Calender Week 09, 2024 [VOID] 10-Mar-2024 │ bits 0x42 - Calender Week 08, 2024 [VA] 21-Feb-2024 │ bits 0x41 - Calender Week 07, 2024 [VOID] 21-Feb-2024 │ bits 0x40 - Calender Week 06, 2024 [VOID] 05-Feb-2024 │ bits 0x39 - Calender Week 05, 2024 29-Jan-2024 │ bits 0x38 - Calender Week 04, 2024 24-Jan-2024 │ bits 0x37 - Calender Week 03, 2024 16-Jan-2024 │ bits 0x36 - Calender Week 02, 2024 [VA] 13-Jan-2024 │ bits 0x35 - Calender Week 01, 2024 03-Jan-2024 │ bits 0x34 - Calender Week 52, 2023 31-Dec-2023 │ bits 0x33 - Calender Week 51, 2023 17-Dec-2023 │ bits 0x32 - Calender Week 50, 2023 [VOID] 17-Dec-2023 │ bits 0x31 - Calender Week 49, 2023 06-Dec-2023 │ bits 0x30 - Calender Week 48, 2023 26-Nov-2023 │ bits 0x2f - Calender Week 47, 2023 20-Nov-2023 │ bits 0x2e - Calender Week 46, 2023 14-Nov-2023 │ bits 0x2d - Calender Week 45, 2023 09-Nov-2023 │ bits 0x2c - Calender Week 44, 2023 30-Oct-2023 │ bits 0x2b - Calender Week 43, 2023 22-Oct-2023 │ bits 0x2a - Calender Week 42, 2023 17-Oct-2023 vis/ │ this building must be haunted 11-Oct-2024 │ Belgien 07-Sep-2024 │ C _o_ r e^ 31-Jul-2024 │ Pieces 28-Nov-2023 │ Dresden 28-Nov-2023 │ a Neon Dream 28-Nov-2023 │ Idols 28-Nov-2023 │ Memes 01-Jan-1970 notes/ │ Synchronisationbegriffe - WIP 11-Nov-2025 │ toolchain and runtimes/ │ │ GNU toolchains 20-Oct-2025 │ │ C Runtime 20-Oct-2025 │ │ cmake notes 10-Dec-2024 │ │ the GNU autosomething 04-Dec-2024 │ │ Makefile 22-May-2020 │ Betriebssysteme (ohne) Sicherheit/ │ teach myself bioinformatics/ │ │ read 28-Feb-2025 │ │ bioshocks (pun intended!) 27-Feb-2025 │ │ glossary 27-Feb-2025 │ algo/ │ │ 快速幂模的两种实现 30-Nov-2020 │ archived/ │ │ CBSE notes 13-Apr-2021 │ │ Vektorraum, Untervektorraum und Spannraum 19-Nov-2020 │ │ Prozess & Thread 10-Nov-2020 │ hw/ │ │ VLIW archs 03-Jun-2025 │ │ SDRAM intro 28-May-2025 │ │ ECC memory and bitflip handling 30-Apr-2025 │ │ device tree (linux) /// WIP 30-Jan-2025 │ │ TSC and High precision time measuring 29-Nov-2024 │ │ Caching Mapping / 缓存映射 08-Jun-2021 │ │ aarch64/ │ │ │ mnemonics 25-Oct-2023 │ │ FPGA stuffs/ │ │ memory and cache/ │ │ │ Memory Model and Formalization 07-May-2025 │ │ │ MC-02h - memory constency intro & sequential consistency 06-May-2025 │ │ │ MC-01h - coherence introduction 05-May-2025 │ │ x86/ │ lang/ │ │ bash/ │ │ │ frequently used 01-Nov-2024 │ │ c lang/ │ │ │ L/R values, reference, copy and move semantics 16-May-2025 │ │ │ C++ std string and string_view 16-May-2025 │ │ │ C++ std::thread (std <= 17) 16-May-2025 │ │ │ C++ lambda 14-May-2025 │ │ │ C with class 12-May-2025 │ │ │ libcommon (todo) 04-Feb-2025 │ │ │ gettext library : i18n for c 04-Feb-2025 │ │ │ c/c++ inline, const and static 28-Jan-2025 │ │ │ dealing with commandline args 28-Jan-2025 │ │ │ C++ hacks 14-Jan-2025 │ │ │ Smart Pointer 15-Dec-2024 │ │ │ modern c features 15-Dec-2024 │ │ │ GCC inline assembly 29-Nov-2024 │ │ │ C++ de-alienation / 祛魅 26-Nov-2024 │ │ │ struct inheritence 04-Oct-2023 │ │ │ {variable scope trick, nested declaring, bitfield} 08-Aug-2022 │ │ │ Const Expression in c++ 11-Apr-2022 │ │ │ 指针传参hack 09-Jul-2019 │ │ │ modern CPP/ │ │ │ │ modern cpp features - C++11 15-Dec-2024 │ │ │ │ modern cpp features - C++14 15-Dec-2024 │ │ │ │ modern cpp features - C++17 15-Dec-2024 │ │ │ │ modern cpp features - C++20 15-Dec-2024 │ │ │ │ modern cpp features - overview 15-Dec-2024 │ │ go/ │ │ │ examples all in one 31-Dec-2024 │ │ lua/ │ │ │ learn lua (WIP) 02-Jun-2025 │ │ python/ │ │ │ python package management and virtual env 27-Feb-2025 │ │ rust/ │ │ │ Rust modules structure in a nutshell 05-Jan-2023 │ linux/ │ │ process, thread, task 27-Oct-2025 │ │ serial tty 23-Jan-2025 │ │ linux file permissions 21-Jan-2025 │ │ install linux (Deibian) w/ bare qemu 29-Oct-2024 │ │ {SeLinux, MAC, LSM, DAC, AppArmor} 17-Oct-2024 │ │ device number 1 12-Jul-2020 │ │ device number 2 12-Jul-2020 │ │ tooltips/ │ │ │ input output, file, pipe, redirections and parameters 23-Jan-2025 │ │ │ linux FS tools {mount, overlay, chroot} 30-Oct-2024 │ │ │ disk encryption (ext4) 18-Jul-2020 │ │ │ mount commands 23-Jun-2020 │ microkernel/ │ │ L4RE hands-on : build system 01-Jul-2025 │ │ Genode and Trusted Computing 20-Jun-2025 │ │ L4RE hands-on : language quirks (WIP) 27-May-2025 │ │ L4RE CODE READING : IPC, object, task, low-level 26-May-2025 │ │ L4RE hands-on : adding a package / service (WIP) 23-May-2025 │ │ L4RE hands-on : hello world and boot ISO 19-May-2025 │ │ l4RE hands-on : basic concepts 29-Apr-2025 │ misc/ │ │ statistic tools - 去海边整点统计工具 04-Jul-2025 │ │ Diffie–Hellman key exchange 03-Jun-2025 │ │ the DWARF Debugging Information Format (V5) 04-Mar-2025 │ │ Lambda-calculus: 布尔逻辑 09-Jun-2021 │ │ Lambda 演算 07-Jun-2021 │ │ Extensionality 07-Jun-2021 │ │ IEEE754 单精度浮点数 25-Nov-2020 │ multicore, synchronization and locks/ │ │ The Art of Multiprocessor Programming - Notiz 03-Jul-2025 │ │ Reader/Writer Locks 12-May-2025 │ │ linux futex (fast user-space locking) 11-May-2025 │ │ ia32 instructions and micro-arch for locks 10-May-2025 │ │ some atomic memory operations 08-May-2025 │ │ linux kernel synchronization (WIP) 08-May-2025 │ │ List synchronization, from coarse-grained to non blocking wait-free 08-May-2022 │ │ Quiescent consistency, sequential consistency and linearizability 20-Aug-2021 │ │ Basics of mutual exclusion and locks 29-Apr-2021 │ RDMA / infiniband/ │ │ RDMA 101 - libverbs APIs and hello world 21-Jul-2025 │ │ RDMA 101 - basics 21-Jul-2025 │ system administration/ │ │ frequenctly used 10-Apr-2025 │ │ pleroma maintainece notes 09-Apr-2025 │ │ infrasturctures 04-Feb-2025 │ system tracing and profiling/ │ │ perf cheatsheet 27-Oct-2024 │ tooling/ │ │ container, k8s, docker, podman 08-Sep-2025 │ │ COLLECTION OF DEV TOOLS 03-Feb-2025 │ │ Latex basic 04-May-2021 │ │ GPG Quick Notes 18-Nov-2020 │ │ rsync basic usage 28-Oct-2020 │ │ AWK basic usage 14-Jul-2020 my music/ │ die Todgeweihten interview (chinese) 21-Jun-2021 │ Reflections on the isomorph album (cn+en) 14-Jun-2021 │ Isomorph 11-Jun-2021 │ My music projects - overview (chinese) 07-Jun-2020 │ My music projects - overview and listens 07-Jun-2020 cred/ │ ausland 23-Jun-2025 │ hello 23-Jun-2025 code reading/ │ bits worth learning 17-Feb-2025 │ pv (pipe viewer) - manipulate pipe and stream 17-Feb-2025 │ Bochs code reading, notes and hacks 09-Oct-2024 │ coreutils/ │ │ prologue of main tldr it doesn't matter 28-Jan-2025 │ linux/ │ │ timer interrupt 02-Jun-2025 │ │ Machine Check Handling (AMD64) 10-May-2025 │ │ fix my bluetooth keyboard/ │ │ misc/ │ │ │ TODOs in linux code reading 29-Jan-2025 │ │ │ per cpu variables 29-Jan-2025 │ │ │ snippets, quick facts and takeaways 22-Jan-2025 │ │ │ Booting Process (WIP) 22-Jan-2025 │ │ │ interesting places to look at 06-May-2024 │ │ patches/ │ │ │ x86: Put hot per CPU variables into a struct 29-Jan-2025 │ │ │ pack struct file for cacheline optimizations 21-Jan-2025 │ │ sync/ │ │ │ spinlock impl 13-May-2025 │ │ │ CONFIG_DEBUG_SPINLOCK 13-May-2025 │ │ │ lockdep 13-May-2025 │ │ │ R/W lock impl 13-May-2025 │ │ │ RCU fundamentals 17-Oct-2024 Bin/

Comm

i@shrik3.com (SHRIK3) — Sun, 19 Jan 2025 00:53:20 +0100

FEEDBACK & COMMENTS

Commenting on this blog

Please send an email to
i+comment@shrik3.com

use plaintext email only
emails sent to the above address will be made public; to keep it private, make it explicit in your message, or reach out via other handles listed below
your email address will NEVER be disclosed, even if you want to
optionally, specify a display name (default anonymous)

Other social handles

fedi: @shrik3@vnil.de
IRC: shrik3@libera.chat
email: i[at]shrik3[dot]com
matrix: @shrik3:matrix.vnil.de

totally paranoid WWW guidelines

i@shrik3.com (SHRIK3) — Fri, 17 Jan 2025 10:54:39 +0100

This post is inspired by the triology of motherfucking websites¹.

Table of Contents

§ your color is not my color

The best colorscheme is no colorscheme. decorations. Use HTML defaults where applicable. and leave maximum freedom to the client side decorations. Some think “my design is cool/easist to read/…”. No it’s not, people have their preference, let them decide.

Check out the appendix for an example of minimal color usage.

§ especially don’t use a dark theme

This may hit like a hot take. Many “geeks” are obsessed with the dark theme. I agree it’s cool. And I strongly agree that black-on-white can be painful to read in dark environment – that’s why I have the Dark Reader plugin in my browser.

That said, from the accessibility perspective, it’s not up to you, the site owner, to decide whether to present dark or light theme, or anything in between. There are people who prefer dark mode and there are people who prefer otherwise. However, while it’s trivial to turn a light-themed page into dark mode, it’s not easy to do the other way around with a browser plugin.

As said in the first point: do as little theming as possible and leave the decision to the client side.

§ your font is not my font

Perhaps you could specify font families like monospace, serif .... Or use a font that are widely available. Otherwise don’t tell me which font I should use to read your text, unless that page is essentially aesthetics oriented²

§ avoid divitis

divtis ~wiktionary: (web design, usually derogatory) The practice of authoring web-page code with many div elements in place of meaningful semantic HTML elements.

div has no semantic meaning. It’s just an arbitrary thing that is linked to a style via its class, id or selector. This makes it harder for screen readers to parse the page – the screen reader doesn’t digest the page as you do, it needs to understand the page structure. If it sees a <h1> it knows here starts a chapter. If it sees a <strong> it knows something is emphasized. It doesn’t know your title unless you put a <title>. All of these matter to a visually-impaired person. And there ain’t too many of them to learn³. When adding elements to your site, instead of “how it should look”, think about “what is is”.

The second point is, while the html elements are well-defined in the W3C specifications and well supported by most (even TUI based) browsers, your homebrew <div>s are not.

Continuing on the last point.

at least try to access your site with a screen reader : and it will turn out to be total crap; be ashamed.
If you have time, please check out the ARIA⁴ labels.

If you structure your site with good basic html instead of divtis and/or scripts, your site is pretty much automatically screen-reader friendly.

§ sanity checks

is your page readable in w3m?

Just open your site from a terminal browser like w3m or lynx. If the site is barely readable, your site is broken. Even worse, if your site require JavaScript to work properly, your site is totally broken. Of course there are applications where JS is indeed needed. I’m not denying those. But at least you should have a <noscript> alt text.

is your page readable with no css at all?

CSS (and in some cases, JavaScripts) are there to make things look better, not to make a broken piece of shit tolerable. Now (if you are using firefox), go to menu - view - page style - no style. Is your site totally broken? If yes, you need to relearn html.

§ serve assets yourself

This is simple: if your site need a specific font, a style sheet, or (:frown) a script, serve them locally. Do not let me fetch trivial stuffs from a 3rd party. There may be exceptions for media files due to bandwidth and storage limits. If you have to use CDNs, object storage etc. Make sure you are not accidentally tracking yours users.

§ put alt text in the content body, not as media attribute

This is my personal take. While it’s a politically correct (in a positive tone) to use alt text, many people use it in a way that bothers me.

Like, people post an image on social media with no comment at all what they mean by sharing this image. Understanding an image is somehow subjective, everyone can draw their conclusion and it’s very likely different than that of the people who post it.

On the other hand, they are well behaved netizens who write thorough alt text… Which is more than just descriptive! It’s really bizarre that even people who can see the media need to click into the alt text to understand what it’s about.

What about, simply put your alt text EXPLICIT, so that everyone can just see it?

shrik3 says 2 mins ago:
-----------------------
hahaha. [image]

alt text: // what the image is about //

This also (potentially) makes it easier for a blind person to read your story: they are reading a full story from top to the bottom, instead of having a clueless text with few attached images and forced to check for the alt text.

If the image is contextual (like those on the news) it can be helpful. But literally, what’s the fucking point of a decorative banner image? It’s there only to waste space and bandwidth. It doesn’t make your post look better, it doesn’t help the reader to grasp the idea or to understand your content…

Also, I’ll fart in your general direction, if you use AI-generated banner image.

§ hyperlinks

The problem of a hyperlink like this is that there is no indication to the slightest where it could lead to (unless you inspect it before you click, but how many people are bothered to do so?). I suggest at least not using a link text “like this”, “here”, “an example”.. Use something more descriptive. And use footnotes if you can.

More dangerously, the hyperlinks could hide tracking elements if the author is ignorant, or even phishing attempts if the author is malicious.

Does this link lead to where it claims?
https://google.com

<a href="url-phishing-site">
    your-bank.example.com
</a>

Actually this is one thing on my WWW wishlist: if a hyperlink looks like an URL, it should point to exactly what the text says.

§ broken links are terrible

It’s frustrating to follow a reference link only to find the server is down or the page is gone. There are two things you can do:

link to a page snapshot from the internet archive. If the page you are referencing is not yet archived, just request it.
always include the full title and author in your reference (e.g. in the footnote). If it is from a publication, use proper bibliography format.

This also applies to your own site: if you are moving stuffs around, like from

your.example.com/post/this_article to your.example.com/archive/this_article

Anyone who holds a link to the old url will be greeted with a 404. You static site generator should provide redirect or url alias supports. If you are re-organizing stuffs on on your file system only, you can explicitly tell the generator which url to use. e.g. with hugo

---
url: /post/this_article
---

so that the url doesn’t change. Or if you really want to re-organize the contents, add a redirect to the old url, e.g.

---
aliases: /post/this_article
---

This is not optimal, for example redirects doesn’t keep the IDs in url. If someone visits example.com/your_old_url/#section42 they will be redirected to example.com/your_new_url/. But at least it’s not a frustrating 404.

Another problem is RSS feeds. Typically RSS will use URLs as IDs of a page. If you are changing the URL this article is “duplicated” on the reader end. But there is no good sulution to that – this is how RSS works.

§ let there be structural anchors

You should’ve already noticed, on this page, every heading is led by # sign, which is hyperlinked to this page with an id selector.

In html code, it looks like this:

<h1 id="your-color-is-not-my-color">
  <a href="#your-color-is-not-my-color">#</a>
  your color is not my color
</h1>

When you click on this URL, you are taken to this very point instead of just the top of the article. This is extremely helpful for sharing.

§ no pagination on a trivial list, on a static site.

There are some good reasons to use paginations, e.g.

you are using dynamic site (as opposed to static), the backend (cgi) process is very expensive and/or you have very high traffic.
it’s very high volume (e.g. a mailing list archive)
it’s a “feed” rather than a list.

But say you have some dozens, maybe hundreds of pages. It’s pointless to render only 20 of them on a trivial list, and then have a prev / next button. By “trivial list” I mean an index of your pages, e.g.

https://shrik3.com/post

Simply put them all on the same page. It’s much easier to locate an article, either with linear search, or with browser Ctrl-F. Also it saves you a lot of shitty code in your generator templates.

§ size matters … but it depends

Let’s do a puzzle, below are html elements of different sizes. I promise they are all vanilla html without any style sheet. Can you match them into the following elements with your eyes? you are allowed to use a ruler :) I fucking dare you.

<h1> through <h6>
<p> with different font-size  (x-small, smaller, normal, larger, x-large)
<strong>
<tt>

do you know that <h1> (1) and <h2> (2 and 3) have the same size if they are in an <article> block?
do you know that <h4> (4) is the same size as <p> (5); <h5> (11) and <h6> are smaller than <p> (12)?
do you realize that capital text looks bigger than lowercase text? (1,2,3 have same size)

But these are not the point. The point is that you should NOT have too many gradients of sizes. Your human visual cortex sucks at recognizing sizes when they are not compared side-by-side. You may want to use proper headings to keep the text structured (please do); you may want to apply different font sizes (e.g. smaller, larger …) to html elements to make the page more pleasant to the eyes … You could do that but never rely on any ambiguous encoding. Text is clearer than symbols, symbols are clearer than sizes and color … etc.

hello 1

HELLO 2

hello 3

hello 13

hello 5

hello 6

hello 7

hello 4

hello 8

hello 9

hello 10

hello 11

hello 13

hello 12

§ what license?

This is not a debate whether you should allow others to use your content – you have every right to forbid copying or reusing of your own works.

But if you do want to share your works, specifying a proper license helps a lot. On one hand, many creative works use a “non-permissive” license, that is, if you use their work, you are required to to use a compatible license for your work.

On the other hand, There is the misconception that copyright & license specifications are there restrictions (as in, text wall of requirements and legal terms). The fact is quite the opposite, license is permission, not restriction. Because the strictest restriction is that you don’t specify a license at all – where your works by default are under exclusive copyrights.

Saying nothing about license ~= not allowing any form of reusing.

For a good start, check out the Common Creatives (CC) Licenses

PS. For code, also check out https://choosealicense.com/

PPS. You don’t need to assume good faiths in human. Those big techs won’t give a fuck what you say about license – and they have good lawyers. But for those who do come to you in good faith, a proper license makes good relief!

§ HTTPS

Do I need to elaborate on this one?
Does my site need https?

§ appendix: colors

I didn’t say that – Mark Twain

totally bloated rules of thumb

foreground & background that have slightly less contract than black & white
a slightly dimmed foreground color e.g. grey, for auxiliary text that draws less attentions, like comments.
a background color that draws some attention, e.g. to highlight a line of code, or to highlight the targeted html element.
and stop trying to add more

Coloring by itself itself is meaningless and could be harmful if you use them wrong⁵. You UI must not rely on color. In the following example I have line 3 highlighted, this is totally cool and convenient. But keep mind that this hint will be totally ignored by a screen reader.

// guess what's wrong here?
int main() {
    *(0) = 42;
    return 0;
}

§ appendix: backlog

some other stuffs

url management: make minimal effort to make the url itself readable, or semantic if possible. E.g. simply digest a few keywords from your title and put them in the url.
```
https://example.com/post/how-to-make-good-urls
```
instead of:
```
https://example.com/post/928501239
```
but of course this would depend on your actual setup.

this is a motherfucking website
and this is a better motherfucking website
and finally this is the best motherfucking website
as the best motherfucking website ponints out, the better motherfucking website actually sucks ↩︎
one positive example I could think of is the oldschool pc fonts site: https://int10h.org/oldschool-pc-fonts/ .. Because why not! Also I have a few pages that uses nerdy styles like my about page … ↩︎
https://www.w3schools.com/TAGs/ ↩︎
https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA ↩︎
Color Encoding is Ableism /take/#color-encoding-is-ableism ↩︎

C++ hacks

i@shrik3.com (SHRIK3) — Tue, 14 Jan 2025 18:54:40 +0100

Copying: CC BY-SA 3.0

§ OBJECT ORIENTED `me.getFucked()`

§§ type alias with templates:

// this works
template <typename T>
using RingBuffer = boost::circular_buffer<T>;

// this doesn't
template <typename T>
typedef RingBuffer boost::circular_buffer<T>;

// neither does this
typedef RingBuffer<T> boost::circular_buffer<T>;

§§ override parent methods

§§ delete a (virtual) function from derived class

https://stackoverflow.com/questions/24609872/delete-virtual-function-from-a-derived-class

If the method is called however, the struct is defined and its value is false, so the static_assert fails. If the method is not called, but you try to call it on a pointer of the super class, then Ds method is not defined and you get an undefined reference compilation error.

template <typename T>
struct fail : std::false_type
{
};

class B
{
public:
    virtual void f() {}
};

class D : public B
{
public:
    template<typename T = bool>
    void
    f()
    {
        static_assert (fail<T>::value, "Do not use!");
    }
};

§ assertion and pacnic

§§ “virtual inheritance”

examples all in one

i@shrik3.com (SHRIK3) — Tue, 31 Dec 2024 05:02:54 +0100

https://git.sr.ht/~shrik3/learngo

// this is a remix of multiple documentations / tutorials / blogs.
// multlicensed under:

// SPDX-License-Identifier: EUPL-1.2
// SPDX-License-Identifier: CC-BY-3.0
// SPDX-License-Identifier: BSD-3-Clause

// code from https://gobyexample.com
// 	Copyright Mark McGranaghan
// 	Copyright Renée French
// code from https://go.dev/tour/list
// 	Copyright 2011 The Go Authors.
// code / notes from https://go.dev/blog/slices-intro
// 	Copyright Andrew Gerrand

package main

import (
	"errors"
	"fmt"
	"iter"
	"maps"
	"math"
	"reflect"
	"slices"
	"sync"
	"time"
	"unicode/utf8"
)

// 3 - constants
const const_s string = "constant hello world"

func main() {
	fmt.Println("hello world")

	// values, variables and constants ///////////////////////////////////////
	fmt.Println("go" + "lang") // golang
	fmt.Println("1+1=", 1+1)   // 2
	fmt.Println("7.0/3.0=", 7.0/3.0)
	fmt.Println(true && false) // false
	fmt.Println(true || false) // true
	fmt.Println(!true)         // false

	var a = "initial"
	var b, c int = 1, 2 // unlike c, type (class) name comes after var name
	var d = true
	var e int    // is this uninitialized?
	f := "apple" // shorthand for declaring + initialization
	fmt.Println(a)
	fmt.Println(b, c)
	fmt.Println(d)
	fmt.Println(e)
	fmt.Println(f)

	fmt.Println(const_s)
	const n = 500000000
	const n2 = 3e20 / n
	fmt.Println(n2) // 6e+11
	fmt.Println(int64(n2))
	fmt.Println(math.Sin(n))

	// control flows /////////////////////////////////////////////////////////
	fmt.Println("------- - control flows---")
	i := 1
	// while style
	for i <= 3 {
		fmt.Println(i)
		i = i + 1
	}
	// c style
	for j := 0; j < 3; j++ {
		fmt.Println(j)
	}
	// iterator style
	for i := range 3 {
		fmt.Println("range", i)
	}
	// continue
	for n := range 6 {
		if n%2 == 0 {
			continue
		}
		fmt.Println(n)
	}
	// forever and break
	for {
		fmt.Println("loop")
		break
	}

	// statements can precede if conditionals.
	// variables declared here are visible in all branches
	if num := 9; num < 0 {
		fmt.Println(num, "is negative")
	} else if num < 10 {
		fmt.Println(num, "has 1 digit")
	} else {
		fmt.Println(num, "has multiple digits")
	}

	// switch-case; unlike C, only one arm is taken therefore no need for break.
	something := 2
	switch something {
	case 1:
		fmt.Println("one")
	case 2:
		fmt.Println("two")
	case 3:
		fmt.Println("three")
	}

	// can use switch-case as a tidier if-if-else: case can take conditions
	t := time.Now()
	switch {
	case t.Hour() < 12:
		fmt.Println("it's before noon")
	default:
		fmt.Println("it's after noon")
	}

	// likewise for `if` we can bind a value here
	switch day := time.Now().Weekday(); day {
	// can merge multiple arms
	case time.Saturday, time.Sunday:
		fmt.Println(day, "is weekend")
	default:
		fmt.Println(day, "is weekday")
	}

	// type switch : switch on type instead of values whatAmI is a function
	// object, see later note: this can also be done with reflect.TypeOf() an
	// empty interface means pretty much "anything"
	whatAmI := func(i interface{}) {
		switch t := i.(type) {
		case bool:
			fmt.Println("I'm bool")
		case int:
			fmt.Println("I'm int")
		default:
			fmt.Printf("Don't know type %T\n", t)
		}
	}

	whatAmI(true)
	whatAmI(1)
	whatAmI("hello")
	whatAmI(whatAmI)

	// arrays ////////////////////////////////////////////////////////////////
	fmt.Println("--------- arrays ---------")

	// array is zero valued by default
	var arr [5]int
	fmt.Println("init array a[5]int:", arr)
	// accessing by index:
	arr[4] = 100
	fmt.Println("set", arr)
	fmt.Println("get @4", arr[4])
	whatAmI(arr)

	// length
	fmt.Println("length of arr is", len(arr))
	// const initializer:
	arr_2 := [5]int{1, 2, 3, 4, 5}
	fmt.Println("arr_2", arr_2)
	// auto length
	arr_3 := [...]int{1, 2, 3, 4, 5}
	fmt.Println("arr_3", arr_3)
	// syntax suggar, specify index: {100, 0, 0, 400, 500}
	// unspecified elements are default to zero
	arr_4 := [...]int{100, 3: 400, 500}
	fmt.Println("arr_4", arr_4)
	// multi-dimensional
	var arr_2d [2][3]int
	for i := 0; i < 2; i++ {
		for j := 0; j < 3; j++ {
			arr_2d[i][j] = i + j
		}
	}
	fmt.Println("2d arr: ", arr_2d)
	// 2d array const init
	arr_2d = [2][3]int{
		{1, 2, 3},
		{1, 2, 3},
	}
	fmt.Println("2d arr: ", arr_2d)

	// slices ////////////////////////////////////////////////////////////////
	// https://go.dev/blog/slices-intro

	// slices ar edynamically-sized, flexible view into elements of an array
	// (pretty much the same as rust slice?)
	fmt.Println("--------- slices ---------")

	// slice has type []T   (unlike array, no length specified)
	arr_base := [6]int{1, 2, 3, 4, 5, 6}
	// create slice from array with arr_base[low : high]
	// left inclusive, right exclusive
	var arr_slice []int = arr_base[1:4]
	// or omit high/low bounds to use the defaults (0 for low, len for high)
	var arr_slice2 []int = arr_base[:3]
	var arr_slice3 []int = arr_base[:]
	fmt.Println("array_base: ", arr_base, " has type ", reflect.TypeOf(arr_base))
	fmt.Println("array_slice: ", arr_slice, " has type ", reflect.TypeOf(arr_slice))
	// slice is mutable reference to the underlying array
	arr_slice[1] = 42
	fmt.Println("arr_base after mod: ", arr_base)
	// all slices to the array base sees the modification
	fmt.Println("arr_slice2 after mod: ", arr_slice2)
	fmt.Println("arr_slice3 after mod: ", arr_slice3)
	// slice has length and capacity
	// read with len(s) and cap(s)
	// cap is length of underlying array, _counting from slice low bound_
	fmt.Println("arr_slice has length ", len(arr_slice), "and cap ", cap(arr_slice))

	// slices can be trimmed or extended (given slice has enough capacity)
	arr_slice = arr_slice[:0]
	sliceInfo(arr_slice) // len = 0, cap=5 []
	// extend the slice
	arr_slice = arr_slice[:4] // looks like out-of-bound but no
	sliceInfo(arr_slice)      // len = 4, cap=5 [2 42 4 5]
	// drop first to values
	arr_slice = arr_slice[2:]
	// slice cap changes when its low bound shifts
	sliceInfo(arr_slice) // len = 2 cap=3 [4 5]
	// there is no way (?) to extend the slice on the lower bound

	// nil slice
	var s_nil []int
	sliceInfo(s_nil) // s_nil == nil

	// append to slice
	// The resulting value of append is a slice containing all the elements of
	// the original slice plus the provided values. If the backing array of s is
	// too small to fit all the given values a bigger array will be allocated.
	// The returned slice will point to the newly allocated array.
	s_nil = append(s_nil, 1)
	sliceInfo(s_nil)               // len 1, cap 1, [1]
	s_nil = append(s_nil, 2, 3, 4) // can take VA
	sliceInfo(s_nil)               // len 4, cap 4, [1 2 3 4]

	// make builtin fuction: make([]T, len, cap)
	// create new, initialized slice value for a given element type T
	// a slice created with make always allocates a new, hidden array to whicvh
	// the the returned slice value refers.
	// sm1 and sm2 are equivalent
	var sm1 = make([]int, 50, 100)
	var sm2 = new([100]int)[0:50]
	fmt.Println("sm1 has type ", reflect.TypeOf(sm1))
	fmt.Println("sm2 has type ", reflect.TypeOf(sm2))

	// slice literals : q is a reference to a (anonymous) constant array
	p := [...]int{1, 2, 3, 4, 5, 6, 7}
	q := []int{1, 2, 3, 4, 5, 6, 7}
	fmt.Println("p has type ", reflect.TypeOf(p))
	fmt.Println("q has type ", reflect.TypeOf(q))

	var s []string
	fmt.Println("uninit:", s)
	s = make([]string, 3, 3)
	// shorthand : can use make([]T, len)
	s[0] = "apple"
	s[1] = "banana"
	s[2] = "carrot"
	s = append(s, "e", "f", "g")
	fmt.Println(s, "len:", len(s), "cap:", cap(s))

	// 2d slices (like 2d array)
	slice_2d := make([][]int, 3)
	for i := 0; i < 3; i++ {
		innerLen := i + 1
		slice_2d[i] = make([]int, innerLen)
		for j := 0; j < innerLen; j++ {
			slice_2d[i][j] = i + j
		}
	}
	fmt.Println("2d slice ", slice_2d)
	// slices package functions
	// slices. {Max, Min, Equal, Grow ....}

	// maps //////////////////////////////////////////////////////////////////
	// https://go.dev/blog/slices-intro
	fmt.Println("--------- maps -----------")
	// create map
	// make(map[key_type]val_type) // TODO: what's under the hood?
	m := make(map[string]int)
	m["k1"] = 7 // if key doesn't exist a new pair is created
	m["k2"] = 13
	m["k3"] = 0
	fmt.Println("map: ", m) // [k1:7 k2:13 k3:0]
	fmt.Println("len of map:", len(m))
	fmt.Println("v1: ", m["k1"]) // 7
	fmt.Println("v2: ", m["k2"]) // 13
	fmt.Println("v3: ", m["k3"]) // 0
	// if key doesn't exist, returns default value (0)
	fmt.Println("v_na: ", m["kna"])

	// disambiguate between missing keys and zero-valued keys
	// optionally return a presence bool from map
	v, present := m["kna"]
	fmt.Println("presence of kna ", present, " value is ", v) // false, 0

	delete(m, "k2")         // remove a kv pair
	fmt.Println("map: ", m) // [k1:7 k3:0]
	delete(m, "kna")        // no error reported when deleting non-exist
	fmt.Println("map: ", m) // [k1:7 k3:0]

	clear(m)                // remove everything
	fmt.Println("map: ", m) // []

	// inline declaration
	map1 := map[string]int{"foo": 1, "bar": 2}
	map2 := map[string]int{"foo": 1, "bar": 2}
	// map equal?
	if maps.Equal(map1, map2) {
		fmt.Println("n1 == n2: ", map1)
	}

	// range /////////////////////////////////////////////////////////////////
	// iterate over array (slice) with auto index (from 0)
	for i, n := range arr_base {
		fmt.Printf("%d:%d ", i, n)
	}
	fmt.Println()
	// range index always starts from 0
	for i, n := range arr_base[2:] {
		fmt.Printf("%d:%d ", i, n)
	}
	fmt.Println()

	// range over map:
	kvs := map[string]string{"a": "apple", "b": "banana"}
	for k, v := range kvs {
		fmt.Printf("%s -> %s \n", k, v)
	}

	// range over string: (by unicode rune)
	for i, c := range "go" {
		fmt.Println(i, c)
	}

	// with widechars the indexing will be quite different (TODO)
	// https://gobyexample.com/strings-and-runes
	// for i, c := range "测试" {
	// 	fmt.Println(i,c)
	// }

	// pointers //////////////////////////////////////////////////////////////
	// just like c.
	f_val := func(ival int) {
		ival = 0
	}

	f_ptr := func(iptr *int) {
		*iptr = 0
	}
	test_vi := 1
	fmt.Println(test_vi) // 1
	f_val(test_vi)
	fmt.Println(test_vi) // 1
	f_ptr(&test_vi)
	fmt.Println(test_vi) // 0
	fmt.Println("ptr addr:", &test_vi)

	// strings and runes (TODO) //////////////////////////////////////////////
	const test_s = "测试"
	fmt.Println("string: ", test_s, " len: ", len(test_s), " runes: ", utf8.RuneCountInString(test_s))
	// strings are equivalent to []byte, iterating results in raw bytes
	for i := 0; i < len(s); i++ {
		fmt.Printf("%x ", s[i])
	}
	fmt.Println()

	// range over string gets runes. The idx is byte idx where the rune starts
	for idx, runeValue := range test_s {
		// use %U to print a rune
		fmt.Printf("%#U starts a at %d\n", runeValue, idx)
	}

	// type rune and literals
	examineRune := func(r rune) {
		if r == '试' {
			fmt.Println("found \"试\"")
		}
	}

	// manually decode runes from raw byte array
	for i, w := 0, 0; i < len(test_s); i += w {
		runeValue, width := utf8.DecodeRuneInString(test_s[i:])
		fmt.Printf("%#U starts at %d\n", runeValue, i)
		w = width
		examineRune(runeValue)
	}

	// structs / embedded structs ////////////////////////////////////////////
	// TODO: https://gobyexample.com/struct-embedding
	// create a type "person" from a struct
	type person struct {
		name string
		age  int
	}

	test_p := person{name: "john"} // age will take default value
	test_p.age = 42
	test_p2 := person{name: "alice", age: 24}
	fmt.Println(test_p, test_p2)

	// automatic dereference
	fmt.Println(test_p.name)
	test_p_ptr := &test_p
	fmt.Println(test_p_ptr.name)

	// anonymous struct:
	dog := struct {
		name   string
		isGood bool
	}{
		"Rex",
		true,
	}
	fmt.Println(dog)

	// goroutines ////////////////////////////////////////////////////////////
	// add keyword `go` before function calls to run the function concurrently
	test_func := func(str string) {
		for i := 0; i < 3; i++ {
			fmt.Println(str, ":", i)
		}
	}

	go test_func("hello")

	// anonymous
	go func(msg string) {
		fmt.Println(msg)
	}("world")

	// wait group
	var wg sync.WaitGroup

	for i := 1; i <= 5; i++ {
		wg.Add(1)
		go func() { // a wrapper func with to notify finish
			defer wg.Done()
			func(id int) { // the actual worker function
				fmt.Printf("Worker %d starting\n", id)
				time.Sleep(50 * time.Millisecond)
				fmt.Printf("Worker %d done\n", id)
			}(i)
		}()
	}
	wg.Wait()
	// TODO for error propagation from workders, check errgroup package
	// https://pkg.go.dev/golang.org/x/sync/errgroup

	// channels //////////////////////////////////////////////////////////////
	// create a new channel with make(chan valType)
	messages := make(chan string)
	// send a value to channel with `channel <- thing`
	go func() { messages <- "ping" }()
	// receive message from channel with `<- channel`
	msg := <-messages
	fmt.Println(msg)

	// channel with buffering
	messages_2 := make(chan string, 2)
	messages_2 <- "hello"
	messages_2 <- "world"
	// messages_2 <- "foo"
	// exceeding buffer limit
	// fatal error: all goroutines are asleep - deadlock!
	fmt.Println(<-messages_2)
	fmt.Println(<-messages_2)

	// channel and goroutine sync:
	test_chan_func := func(done chan bool) {
		fmt.Println("working")
		time.Sleep(50 * time.Millisecond)
		done <- true
	}
	done := make(chan bool)
	go test_chan_func(done)
	<-done // this will block until the goroutine sends to channel

	// specify channel direction in function parameter
	ping := func(pings chan<- string, msg string) {
		pings <- msg
	}
	pong := func(pings <-chan string, pongs chan<- string) {
		msg := <-pings
		pongs <- msg
	}
	pings := make(chan string, 1)
	pongs := make(chan string, 1)
	go ping(pings, "hello")
	go pong(pings, pongs)
	fmt.Println("received from pongs: ", <-pongs)

	// select : wait on multiple channels (like unix epoll)
	c1 := make(chan string, 1) // buffered, non-blocking send
	c2 := make(chan string, 1)
	go func() {
		time.Sleep(1 * time.Second)
		c1 <- "one"
	}()
	go func() {
		time.Sleep(2 * time.Second)
		c1 <- "two"
	}()

	for i := 0; i < 2; i++ {
		select {
		case msg1 := <-c1:
			fmt.Println("received", msg1)
		case msg2 := <-c2:
			fmt.Println("received", msg2)
		case <-time.After(3 * time.Second):
			// implements a timenot, note that channels are buffered and sends
			// are non-blocking
			fmt.Println("timeout 3")
		}
	}

	// non-blocking channels
	messages_3 := make(chan string)
	messages_4 := make(chan string)
	// messages_3 is unbuffered; send/receive typically blocks
	// however this select will not block with a default select case
	// multi-way nonblocking select:
	select {
	case msg := <-messages_3:
		fmt.Println("received message 3", msg)
	case msg := <-messages_4:
		fmt.Println("received message 4", msg)
	default:
		fmt.Println("no message received")
	}

	// TODO closing a channel
	close(messages_3)
	close(messages_4)
	// TODO worker pools
	// https://gobyexample.com/worker-pools
	// TODO rate limiting
	// https://gobyexample.com/rate-limiting

	// iterate / range over channels
	messages_5 := make(chan string, 2)
	messages_5 <- "one"
	messages_5 <- "two"
	close(messages_5) // need to close before iterating
	for elem := range messages_5 {
		fmt.Println(elem) // one two
	}

	// nonblocking send
	select {
	case messages <- "hello":
		fmt.Println("sent message hello")
	default:
		fmt.Println("no message sent")
	}

	// timers and tickers ////////////////////////////////////////////////////
	// TODO https://gobyexample.com/timers
	// TODO https://gobyexample.com/tickers

	// atomic types ; mutex //////////////////////////////////////////////////
	// TODO https://gobyexample.com/atomic-counters
	// TODO stateful goroutines (BOOKMARK!!!!)
	// https://gobyexample.com/stateful-goroutines

	// sugars ..//////////////////////////////////////////////////////////////
	// 不是，你们go玩家吃的都那么好的吗
	// inlined declaration (anonymous type)
	arr_struct := []struct {
		i int
		b bool
	}{
		{1, true},
		{2, false},
		{3, true},
	}
	fmt.Println(arr_struct)

	// turn slice into multiple arguments:
	nums := []int{1, 2, 3, 4}
	fmt.Println(sums(nums...))

	// x - keywords and builtin functions ///
	fmt.Println("--- [x] - keywords -------")
	// make, new

	// other tests ///////////////////////////////////////////////////////////
	fmt.Println(sums(1, 2, 3, 4))
	// use ... to expand slice into variadic attrs
	fmt.Println(sums(nums...))
	// closure:
	nextInt := intSeq()
	fmt.Println(nextInt()) // 1
	fmt.Println(nextInt()) // 2
	fmt.Println(nextInt()) // 3
	fmt.Println(nextInt()) // 4
	newInt := intSeq()
	fmt.Println(newInt()) // 1
	// return function local reference safely
	sth := new_something("hello", 42)
	fmt.Println(*sth)

	// test methods + auto value/ptr conversion
	r := rect{width: 10, height: 5}
	rp := &r
	fmt.Println("area: ", r.area())    // 50
	fmt.Println("perim:", r.perim2())  // 30
	fmt.Println("area: ", rp.area())   // 50
	fmt.Println("perim:", rp.perim2()) // 30

	// test interfaces
	cir := circle{radius: 5}
	measure(cir)
	measure(r)

	// test enums
	ns := transition(StateIdle)
	fmt.Println(ns)
	ns2 := transition(ns)
	fmt.Println(ns2)

	// test generics
	var test_strarr = []string{"foo", "bar", "zoo"}
	// can explicitly specify the types but the compiler can infer the types
	// automatically : below is warning "unnecessary type arguments"
	// _ = SliceIndex[[]string, string](test_strarr, "zoo")
	fmt.Println("index of zoo:", SliceIndex(test_strarr, "zoo")) // 2

	// test generics (linked list)
	lst := List[int]{}
	lst.Push(1)
	lst.Push(2)
	lst.Push(3)
	fmt.Println("list is : ", lst.AllElements())

	// test iterators
	for e := range lst.All() {
		fmt.Println(e)
	}

	// slices.Collect:
	fmt.Println(slices.Collect(lst.All()))
	// "infinite" iterator
	for n := range genFib() {
		if n >= 10 {
			break
		}
		fmt.Println(n)
	}

}

// functions /////////////////////////////////////////////////////////////////
//

func sliceInfo(s []int) {
	fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}

// with return type
func plusplus(a, b, c int) int {
	return a + b + c
}

// with multiple returns, can use blank identifier to ignore a ret value
// a, b := vals()
// _, b := vals()
func vals() (int, int) {
	return 3, 7
}

// variadic functions
func sums(nums ...int) int {
	// nums is slice type: []int
	total := 0
	for _, num := range nums {
		total += num
	}
	return total
}

// closures (anonymous/lambda functions)
// this function returns a function
func intSeq() func() int {
	i := 0
	// i is basically a "static" variable to the returned function.
	// each returned closure instance has its own copy of the variable
	return func() int {
		i++
		return i
	}
}

// recursion
func fact(n int) int {
	if n == 0 {
		return 1
	}
	return n * fact(n-1)
}

// go is GC language, can safely return reference to a function local variable
type something struct {
	name string
	val  int
}

func new_something(name string, val int) *something {
	p := something{name: name}
	p.val = val
	return &p // ok ....
}

// methods ///////////////////////////////////////////////////////////////
type rect struct {
	width, height float64
}

// methods have receiver
func (r rect) area() float64 {
	return r.width * r.height
}

func (r rect) perim() float64 {
	return r.width * r.height
}

// auto conversion between value and pointers
func (r *rect) perim2() float64 {
	return 2 * (2*r.width + 2*r.height)
}

// interface /////////////////////////////////////////////////////////////
// interfaces are named collections of method signatures
type geometry interface {
	area() float64
	perim() float64
}

type circle struct {
	radius float64
}

func (c circle) area() float64 {
	return math.Pi * c.radius * c.radius
}

func (c circle) perim() float64 {
	return 2 * math.Pi * c.radius
}

// take interface as parameter type: i.e. g implements interface geometry
func measure(g geometry) {
	fmt.Println(g)
	fmt.Println(g.area())
	fmt.Println(g.perim())
}

// enums /////////////////////////////////////////////////////////////////
type State int

const (
	// keyword iota generates successive constant values automatically
	StateIdle      State = iota // 0
	StateConnected              // 1
	StateError                  // 2
	StateRetrying               // 3
)

var stateName = map[State]string{
	StateIdle:      "idle",
	StateConnected: "connected",
	StateError:     "error",
	StateRetrying:  "retrying",
}

// .String() method is automatically called when e.g. printing as %s
func (ss State) String() string {
	return stateName[ss]
}

// switch case w/ enums
func transition(s State) State {
	switch s {
	case StateIdle:
		return StateConnected
	case StateConnected, StateRetrying:
		return StateIdle
	case StateError:
		return StateError
	default:
		panic(fmt.Errorf("unknown state: %s", s))
	}
}

// generics //////////////////////////////////////////////////////////////

// function takes a slice of a comparable type E
// and finds the index of first occurrence of value v
// ~ means the type argument for S can be any type whose underlying type is a
// slice type
// https://stackoverflow.com/questions/70888240/whats-the-meaning-of-the-new-tilde-token-in-go

// the [] brackets here is just like <> for c++ and rust
func SliceIndex[S ~[]E, E comparable](s S, v E) int {
	for i := range s {
		if v == s[i] {
			return i
		}
	}
	return -1
}

type List[T any] struct {
	head, tail *element[T] // tail is a pointer to an element with type parameter T
}

type element[T any] struct {
	next *element[T]
	val  T
}

func (lst *List[T]) Push(v T) {
	if lst.tail == nil {
		lst.head = &element[T]{val: v} // empty list, create anew
		lst.tail = lst.head
	} else {
		lst.tail.next = &element[T]{val: v} // append to tail
		lst.tail = lst.tail.next
	}
}

func (lst *List[T]) AllElements() []T {
	var elems []T
	for e := lst.head; e != nil; e = e.next {
		elems = append(elems, e.val)
	}
	return elems
}

// (custom) iterators ////////////////////////////////////////////////////

// returns an iterator from a linked list
func (lst *List[T]) All() iter.Seq[T] {
	// returns a function, that takes a `yield` function as parameter
	// yield is called on every element we want to iterate over
	// * need to check yield return value for early termination
	return func(yield func(T) bool) {
		for e := lst.head; e != nil; e = e.next {
			if !yield(e.val) {
				return
			}
		}
	}
}

func genFib() iter.Seq[int] {
	return func(yield func(int) bool) {
		a, b := 1, 1
		for {
			if !yield(a) {
				return
			}
			a = b
			b = a + b
		}
	}
}

// errors ////////////////////////////////////////////////////////////////
// TODO https://gobyexample.com/errors
// TODO https://gobyexample.com/custom-errors
// TODO matching errors (along the chains)
// by convention, erros are the last return value and have type error
func f(arg int) (int, error) {
	if arg == 42 {
		return -1, errors.New("can't work with 42")
	}
	return arg + 3, nil
}

// custom error type
type argError struct {
	arg     int
	message string
}

// implement method Error() string
// to comply with the error interface
func (e *argError) Error() string {
	return fmt.Sprintf("%d - %s", e.arg, e.message)
}

Smart Pointer

i@shrik3.com (SHRIK3) — Sun, 15 Dec 2024 22:03:02 +0100

§ C++

unique_ptr, shared_ptr and weak_ptr: introduced in c++11, defined in <memory>. They are all containers of a raw pointer.
auto_ptr introduced in c++11, deprecated/removed in c++17.
unique_ptr: Container of a owned raw pointer; does NOT allow copy but supports std::move which transfers ownership.
shared_ptr implements reference counting. Can be copied. The referenced object will be destroyed when and only when all copies of the shared_ptr have been destroyed
weak_ptr: is created as a copy of a shared_ptr, which has no effect on the shared_ptr or its other copies. After all copies of a shared_ptr have been destoyed, all weak_ptr copies become empty

§ references

https://en.wikipedia.org/wiki/Smart_pointe

modern c features

i@shrik3.com (SHRIK3) — Sun, 15 Dec 2024 20:43:04 +0100

§ modern-c-features

NOTE: this is a web “mirror” of Anthony Calandra’s modern-c-features shared under MIT License (see at bottom). The only reason I do a copy is I hate reading markdowns from github. I want something simple and plain for my own reference.

§§ Overview

A collection of descriptions along with examples for C language and library features.

C23 includes the following language features:

C23 includes the following library features:

C17 contains defect reports and deprecations.

C11 includes the following language features:

C11 includes the following library features:

§§ C23 Language Features

§§§ auto

auto-typed variables are deduced by the compiler according to the type of their initializer.

auto f = 123.0f; // `f` deduced to `float`

#include <tgmath.h> // import the `cos` macro
auto c = cos(x); // `c` deduced to a type depending on `x`

#define div(X, Y)            \
  _Generic((X)+(Y),          \
           int: div,         \
           long: ldiv,       \
           long long: lldiv) \
           ((X), (Y))
auto z = div(x, y); // deduced to either `int`, `long`, `long long`

See: generic selection.

§§§ constexpr

Scalars specified with constexpr are constants: they cannot be modified after being initialized, and must be fully initialized to a value that can be stored in the given type.

The C constexpr specifier does not support functions, structures, unions, or arrays. Additionally, constexpr cannot be specified for pointer, atomic, or volatile-qualified types.

`1`	`constexpr size_t cache_line_size_bytes = 64;`

§§§ Decimal floating-point types

Supports IEEE-754 Decimal floating-point types, _Decimal32, _Decimal64, _Decimal128. These floating point types are designed for base-10 floating point semantics.

As of September 2023, compiler support is lacking for most features.

_Decimal32 decsum = 0.0df;
for (int i = 0; i < 10; i++)
    decsum += 0.1df;
printf("%.17Ha\n", decsum); // would print "1.0"

float fsum = 0.0f;
for (int i = 0; i < 10; i++)
    fsum += 0.1f;
printf("%.17f\n", fsum); // could print "1.00000011920928955"

§§§ Bit-width integers

The _BitInt(N) type allows specifying an N bit integer signed or unsigned type.

1
2

_BitInt(4) sbi; // 4-bit width signed integer
unsigned _BitInt(4) ubi; // 4-bit width unsigned integer

§§§ Binary literals

Binary literals provide a convenient way to represent a base-2 number. It is possible to separate digits with '.

1
2

0b110 // == 6
0b1111'1111 // == 255

§§§ char8_t

An unsigned char type for holding 8-bit wide characters.

See: char32_t, char16_t, unicode string literals.

§§§ UTF-8 character literals

A character literal that begins with u8 is a character literal of type char8_t. The value of a UTF-8 character literal is equal to its ISO 10646 code point value.

`1`	`char8_t x = u8'x';`

See: char8_t, unicode string literals.

§§§ Unicode string literals

String literals prefixed with u8, u, and U represent UTF-8, UTF-16, and UTF-32 strings respectively.

See: char32_t, char16_t, char8_t, wide string literals.

§§§ Empty initializer

An object is empty-initialized if it is explicitly initialized using only a pair of braces. Arrays of unknown size cannot be initialized by an empty initializer. If an object is initialized using an empty initializer, default initialization occurs:

Pointers are initialized to NULL;
Decimal floating point types are initialized to positive zero;
Arithmetic types are initialized to zero;
Array types are initialized such that each slot is initialized according to these rules;
Aggregate types are initialized such that each member is initialized according to these rules;
Unions are initialized such that the first named member is initialized according to these rules.

char c = {}; // == 0
float f = {}; // == 0

struct
{
    int x;
    int y;
} f = {}; // == { x: 0, y: 0}

union
{
        char x;
        double y;
} u = {}; // u.x == 0

int ia[5] = {}; // == [0, 0, 0, 0, 0]

§§§ Attributes

Attributes provide a universal syntax over __attribute__(...), __declspec, etc. C++-styled attributes.

C23 provides the following attributes:

[[deprecated("reason")]] - the entity declared with the attribute (such as a function), is deprecated. Specifying a reason is optional and can be ommitted.
[[fallthrough]] - indicates falling-through in a switch statement case is intentional.
[[nodiscard("reason")]] - encourages a compiler warning if the return value for the function declared with this attribute is discarded. Specifying a reason is optional and can be omitted.
[[maybe_unused]] - suppresses a compiler warning on the entity where this attribute is declared if it’s unused (such as an unused function parameter), if applicable.
[[noreturn]] - indicates that the function this attribute is declared on does not return.
Compiler-specific directives - such as [[clang::no_sanitize]].

// `noreturn` attribute indicates `f` doesn't return.
[[noreturn]] void f()
{
    exit(0);
}

See: noreturn.

§§§ New keywords (C23)

New keywords replacing traditional macros definitions:

true and false
thread_local
static_assert

See: static_assert.

§§§ nullptr

Introduces a new null pointer type designed to replace NULL. nullptr itself is of type nullptr_t which can be implicitly converted into pointer types and bool, and – unlike NULL – is not convertible to integral types.

1
2
3

void foo(int);
foo(NULL); // valid
foo(nullptr); // error

§§§ `#embed`

#embed is a preprocessor directive to include text and binary resources directly into source code. This pattern is common in applications such as games that create custom fonts, load images into memory, etc. This allows the C preprocessor to replace external tools that convert resources to byte representations as C arrays.

The #embed preprocessor directive also includes optional parameters including suffix, prefix, and if_empty.

const uint8_t image_bytes[] = {
#embed "image.bmp"
};
 
const char message_text[] = {
#embed "message.txt" if_empty('M', 'i', 's', 's', 'i', 'n', 'g', '\n')
,'\0'
};

§§§ Enums with underlying type

C23 enums provide the ability to optionally specify the underlying type.

enum e : unsigned short
{
    x // `x` is an `unsigned short`
};

§§§ typeof

Gets the type of an expression, similar to decltype in C++. Also includes typeof_unqual which removes cv-qualifiers from the type.

int a;
const volatile int b;
typeof(a) c; // has type of `int`
typeof_unqual(b) d; // has type of `int

§§§ Improved compatibility for tagged types

Tagged types that have the same tag name and content become compatible not only across translation units but also inside the same translation unit. Also, redeclaration of the same tagged types is now allowed.

// header
#define PRODUCT(A ,B) struct prod { A a; B b; }
#define SUM(A, B) struct sum { bool flag; union { A a; B b; }; }

// source
void foo(PRODUCT(int, SUM(float, double)) x)
{
    // ...
}

void bar(PRODUCT(int, SUM(float, double)) y)
{
    foo(y); // compatible type -- compiles
}

§§ C23 Library Features

§§§ Floating-point formatting functions

Converts floating-point values to byte strings. Convert floats, doubles, and long doubles using strfromf, strfromd, and strfroml respectively.

1
2

char buf[BUFFER_SIZE] = {};
strfromf(&buf, BUFFER_SIZE, "%f", 123.0f);

§§§ memset_explicit

Copies the given value into each of the first count characters of the object pointed to by dest. Unlike memset, this function cannot be optimized away by the compiler; therefore, this function is guaranteed to perform the memory write.

1
2

char str[] = "foo";
memset_explicit(str, 0, sizeof(str));

§§§ `unreachable` macro

Provides a standard macro for (historically) compiler-specific macros for denoting an unreachable area of the code.

1
2

if (1 > 0) ...
else unreachable();

§§§ `memccpy`

Copies bytes from source to destination stopping after either the terminating byte is found (and also copied) or the given number of bytes is copied.

// Assume `src` is populated elsewhere.
char dest[MAX_LEN] = {};
// Copy to `dest` until either the NUL terminator (zero) byte
// is found or we are at `MAX_LEN - 1` bytes copied.
memccpy(dest, src, 0, MAX_LEN - 1);

§§§ `strdup` and `strndup`

These functions duplicate a given string by allocating a buffer and copying. The returned string is always null-terminated. Be sure to free the memory returned by thhese functions after use.

const char* src = "foobarbaz";

char* src2 = strdup(src); // "foobarbaz"
free(src2);

char* src3 = strndup(src, 3); // "foo"
free(src3);

§§§ `gmtime_r` and `localtime_r`

Works as gmtime and localtime does but uses a given storage buffer for the result. Returns a NULL pointer on error.

time_t t = time(NULL);

struct tm buf;
struct* tm ret = gmtime_r(&t, &buf);
// ...
struct* tm ret2 = localtime_r(&t, &buf);

§§§ `timespec_getres`

Stores the resolution of time provided by the given base. Returns zero on failure.

struct timespec ts;
const int res = timespec_getres(&ts, TIME_UTC);
if (res == TIME_UTC)
{
    // ...
}

§§ C11 Language Features

§§§ Generic selection

Using the _Generic keyword, select an expression based on the type of a given controlling expression. The format of _Generic is as follows:

_Generic( controlling-expression, T1: E1, ... )

where:

controlling-expresion is an expression that yields a type present in the type list (T1: E1, ...).
T1 is a type.
E1 is an expression.

Optionally, specifying default in a type list, will match any controlling expression type.

#define abs(expr) _Generic((expr), \
    int: abs(expr), \
    long int: labs(expr), \
    float: fabs(expr), \
    /* ... */ \
    /* Don't call abs for unsigned types, etc. */ \
    default: expr \
)

printf("%d %li %f %d\n", abs(-123), abs(-123l), abs(-3.14f), abs(123u));
// prints: 123 123 3.14 99 123

§§§ alignof

Queries the alignment requirement of a given type using the _Alignof keyword or alignof convenience macro defined in <stdalign.h>.

// On a 64-bit x86 machine:
alignof(char); // == 1
alignof(int); // == 4
alignof(int*); // == 8

// Queries alignment of array members.
alignof(int[5]); // == 4

struct foo { char a; char b; };
alignof(struct foo); // == 1

// 3 bytes of padding between `a` and `b`.
struct bar { char a; int b; };
alignof(struct bar); // == 4

max_align_t is a type whos alignment is as large as that of every scalar type.

§§§ alignas

Sets the alignment of the given object using the _Alignas keyword, or alignof macro in <stdalign.h>.

struct sse_t
{
    // Aligns `sse_data` on a 16 byte boundary.
    alignas(16) float sse_data[4];
};

struct buffer
{
    // Align `buffer` to the same alignment boundary as an `int`.
    alignas(int) char buf[sizeof(int)];
};

max_align_t is a type whos alignment is as large as that of every scalar type.

§§§ static_assert

Compile-time assertion either using the _Static_assert keyword or the static_assert keyword macro defined in assert.h.

`1`	static_assert(sizeof(int) == sizeof(char), "`int` and `char` sizes do not match!");

See: new keywords (C23).

§§§ noreturn

Specifies the function does not return. If the function returns, either by returning via return or reaching the end of the function body, its behaviour is undefined. noreturn is a keyword macro defined in <stdnoreturn.h>.

noreturn void foo()
{
    exit(0);
}

See: attributes.

§§§ Wide string literals

Create 16-bit or 32-bit wide string literals and character constants.

char16_t c1 = u'貓';
char32_t c2 = U'🍌';

char16_t s1[] = u"a猫🍌"; // => [0x0061, 0x732B, 0xD83C, 0xDF4C, 0x0000]
char32_t s2[] = U"a猫🍌"; // => [0x00000061, 0x0000732B, 0x0001F34C, 0x00000000]

See: char32_t, char16_t, unicode string literals.

§§§ Anonymous structs and unions

Allows unnamed (i.e. anonymous) structs or unions. Every member of an anonymous union is considered to be a member of the enclosing struct or union, keeping the layout intact. This applies recursively if the enclosing struct or union is also anonymous.

struct v
{
   union // anonymous union
   {
       int a;
       long b;
   };
   int c;
} v;
 
v.a = 1;
v.b = 2;
v.c = 3;

printf("%d %ld %d", v.a, v.b, v.c); // prints "2 2 3"

union v
{
   struct // anonymous struct
   {
       int a;
       long b;
   };
   int c;
} v;
 
v.a = 1;
v.b = 2;
v.c = 3;

printf("%d %ld %d", v.a, v.b, v.c); // prints "3 2 3"

§§ C11 Library Features

§§§ Bounds checking

Many standard library functions now have bounds-checking versions of existing functions. You can specify a callback function using set_constraint_handler_s as a constraint handler when a function fails its boundary check. The standard library includes two constraint handlers: abort_handler_s which writes to stderr and terminates the program; and ignore_handler_s ignores the violation and continue the program.

Standard library functions with bounds-checked equivalents will be appended with _s. For example, some bounds-checked versions include fopen_s, get_s, asctime_s, etc.

Example of a custom constraint handler with get_s:

void custom_handler_s(const char* restrict msg, void* restrict ptr, errno_t error)
{
    fprintf(stderr, "ERROR: %s\n", msg);
    abort();
}

set_constraint_handler_s(custom_handler_s);
char buffer[BUFFER_SIZE];
gets_s(buffer, BUFFER_SIZE);
printf("Entered: %s\n", buffer);

If a user enters a string greater than or equal to BUFFER_SIZE the custom constraint handler will be called.

§§§ timespec_get

Populates a struct timespec object with the current time given a time base.

struct timespec ts;
timespec_get(&ts, TIME_UTC);
char buff[BUFFER_SIZE];
strftime(buff, sizeof(buff), "%D %T", gmtime(&ts.tv_sec));
printf("Current time: %s.%09ld UTC\n", buff, ts.tv_nsec);

§§§ aligned_malloc

Allocates bytes of storage whose alignment is specified.

// Allocate at a 256-byte alignment.
int* p = aligned_alloc(256, sizeof(int));
// ...
free(p);

§§§ char32_t

An unsigned integer type for holding 32-bit wide characters.

See: wide string literals, char16_t, unicode string literals.

§§§ char16_t

An unsigned integer type for holding 16-bit wide characters.

See: wide string literals, char32_t, unicode string literals.

§§§ <stdatomic.h>

§§§§ Atomic types

The _Atomic type specifier/qualifier is used to denote that a variable is an atomic type. An atomic type is treated differently than non-atomic types because access to atomic types provide freedom from data races. For example, the following code was compiled on x86 clang 4.0.0:

_Atomic int a;
a = 1; // mov     ecx, 1
       // xchg    dword ptr [rbp - 8], ecx

int b;
b = 1; // mov     dword ptr [rbp - 8], 1

Notice that the atomic type used a mov then an xchg instruction to assign the value 1 to a, while b uses a single mov. Other operations may include +=, ++, and so on… Ordinary read and write access to atomic types are sequentially-consistent.

See this StackOverflow post for more information.

A variety of typedefs exist which expand to _Atomic T. For example, atomic_int is typedef’d to _Atomic int. See this list for a more complete list.

Atomic types can also be tested for lock-freedom by using the atomic_is_lock_free function or the various ATOMIC_*_LOCK_FREE macro constants. Since atomic_flags are guaranteed to be lock-free, the following example will always return 1:

1
2

atomic_flag flag = ATOMIC_FLAG_INIT;
atomic_is_lock_free(&flag); // == 1

§§§§ Atomic flags

An atomic_flag is a lock-free (guaranteed), atomic boolean type representing a flag. An example of an atomic operation which uses a flag is test-and-set. Initialize atomic_flag objects using the ATOMIC_FLAG_INIT macro.

A simple spinlock implementation using atomic_flag as the “spin value”:

struct spinlock
{
    // false - lock is free, true - lock is taken
    atomic_flag flag;
};

void acquire_spinlock(struct spinlock* lock)
{
    // `atomic_flag_test_and_set` returns the value of the flag.
    // We keep spinning until the lock is free (value of the flag is `false`).
    while (atomic_flag_test_and_set(&lock->flag) == true);
}

void release_spinlock(struct spinlock* lock)
{
    atomic_flag_clear(&lock->flag);
}

void print_foo(void* lk)
{
    struct spinlock* lock = (struct spinlock*) lk;
    acquire_spinlock(lock);
    printf("foo\n");
    release_spinlock(lock);
}

void print_bar(void* lk)
{
    struct spinlock* lock = (struct spinlock*) lk;
    acquire_spinlock(lock);
    printf("bar\n");
    release_spinlock(lock);
}

struct spinlock lock = { .flag = ATOMIC_FLAG_INIT };

// In Thread A:
print_foo(&lock);
// ==============
// In Thread B:
print_bar(&lock);

§§§§ Atomic variables

An atomic variable is a variable which is declared as an atomic type. Atomic variables are meant to be used with the atomic operations which operate on the values held by these variables (except for the flag operations, ie. atomic_flag_test_and_set). Unlike atomic_flag, these are not guaranteed to be lock-free. Initialize atomic variables using the ATOMIC_VAR_INIT macro or atomic_init if it has been default-constructed already.

The C11 Atomics library provides many additional atomic operations, memory fences, and allows specifying memory orderings for atomic operations.

struct spinlock
{
    // false - lock is free, true - lock is taken
    atomic_bool flag;
};

void acquire_spinlock(struct spinlock* lock)
{
    bool expected = false;
    // `atomic_compare_exchange_weak` returns `false` when the value of the
    // flag is not equal to `desired`. We keep spinning until the lock is
    // free (value of the flag is `false`).
    while (atomic_compare_exchange_weak(&lock->flag, &expected, true) == false)
    {
        // `expected` will get set to the value of the flag for every call.
        // Reset it since we always "expect" `false`.
        expected = false;
    }
}

void release_spinlock(struct spinlock* lock)
{
    atomic_store(&lock->flag, false);
}

void print_foo(void* lk)
{
    struct spinlock* lock = (struct spinlock*) lk;
    acquire_spinlock(lock);
    printf("foo\n");
    release_spinlock(lock);
}

void print_bar(void* lk)
{
    struct spinlock* lock = (struct spinlock*) lk;
    acquire_spinlock(lock);
    printf("bar\n");
    release_spinlock(lock);
}

struct spinlock lock;
atomic_init(&lock.flag, false);

// In Thread A:
print_foo(&lock);
// ==============
// In Thread B:
print_bar(&lock);

§§§ <threads.h>

C11 provides an OS-agnostic thread library supporting thread creation, mutexes, and condition variables. Threading library is located in <threads.h>. As of September 2023, it is poorly supported in most major compilers.

§§§§ Threads

Creates a thread and executes print_n in the new thread.

void print_n(int* n)
{
    printf("%d\n", *n); // prints "123"
}

int n = 123;
thrd_t thr;
const int ret = thrd_create(
    &thr, (thrd_start_t) &print_n, (void*) &n);
thrd_join(thr, NULL);

§§§§ Mutexes

C11 provides mutexes that support:

Timed locking - Given a timespec object, blocks the current thread until the mutex is locked or until it times out.
Recursive locking - Supports recursive locking (e.g. re-locking in recursive functions). Recursive timed locks can also be created, capturing both these operations.

Specify which type of mutex to be created by passing any of mtx_plain, mtx_timed, mtx_recursive, or any combination of these to mtx_init’s type parameter.

mtx_t mutex;
const int ret = mtx_init(&mutex, mtx_plain);

// In each thread: =============
mtx_lock(&mutex);
// Critical section
mtx_unlock(&mutex);
// ==============================

mtx_destroy(&mutex);

Mutexes must be cleaned up by calling mtx_destroy.

§§§§ Condition variables

C11 provides condition variables as part of its concurrency library. Condition variables will block when waiting, support timed-waiting, and can be signalled and broadcasted. Note that spurious wakeups may occur.

Condition variables must be cleaned up by calling cnd_destroy.

// Assume remove_from_queue, add_to_queue, and
// can_consume are defined.

mtx_t mutex;
// Initialize mutex...

cnd_t cond;
const int ret = cnd_init(&cond);

// In a consumer thread: =====
// Check in a loop due to spurious wakeups.
while (!can_consume && cnd_wait(&cond, &mutex));
remove_from_queue();
// =========================

// In a producer thread: =====
add_to_queue();
can_consume = true;
cnd_signal(&cond);
// ===========================

cnd_destroy(&cond);

§§§ Quick exiting

Causes program termination to occur where clean termination is not possible or impractical; for example if cooperative cancellation between different threads is not possible or cancellation order is unachievable. This would have resulted in some threads trying to access static-duration objects while they are/have been destructed.

Quick exiting allows applications to register handlers to be called on exit while being able to access static duration objects (unlike atexit). Quick exiting does not execute static-duration object destructors in order to achieve this.

Therefore, quick exiting can be thought of as being “in between” choosing to normally terminate a program, and abnormally terminating using abort.

void f()
{
    // called first
}
 
void g()
{
    // called second
}
 
int main()
{
    at_quick_exit(f);
    at_quick_exit(g);
    quick_exit(0);
}

§§§ Exclusive mode file opening

File access mode flag x can optionally be appended to w or w+ specifiers. This flag forces the function to fail if the file exists, instead of overwriting it.

FILE* fp = fopen(fname, "w+x");
if (!fp)
{
    // File either exists or there was an error
}
else
{
    // File opened successfully.
    fclose(fp);
}

§ COPYING & ATTRIBUTIONS:

Author Anthony Calandra
License: The MIT License (MIT) Copyright (c) 2017 Anthony Calandra

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

modern cpp features - C++11

i@shrik3.com (SHRIK3) — Sun, 15 Dec 2024 20:43:04 +0100

§ C++11

NOTE: this is a web “mirror” of Anthony Calandra’s modern-cpp-features shared under MIT License (see at bottom). The only reason I do a copy is I hate reading markdowns from github. I want something simple and plain for my own reference.

§§ Overview

Many of these descriptions and examples are taken from various resources (see Acknowledgements section) and summarized in my own words.

C++11 includes the following new language features:

C++11 includes the following new library features:

§§ C++11 Language Features

§§§ Move semantics

Moving an object means to transfer ownership of some resource it manages to another object.

The first benefit of move semantics is performance optimization. When an object is about to reach the end of its lifetime, either because it’s a temporary or by explicitly calling std::move, a move is often a cheaper way to transfer resources. For example, moving a std::vector is just copying some pointers and internal state over to the new vector – copying would involve having to copy every single contained element in the vector, which is expensive and unnecessary if the old vector will soon be destroyed.

Moves also make it possible for non-copyable types such as std::unique_ptrs (smart pointers) to guarantee at the language level that there is only ever one instance of a resource being managed at a time, while being able to transfer an instance between scopes.

See the sections on: rvalue references, special member functions for move semantics, std::move, std::forward, forwarding references.

§§§ Rvalue references

C++11 introduces a new reference termed the rvalue reference. An rvalue reference to T, which is a non-template type parameter (such as int, or a user-defined type), is created with the syntax T&&. Rvalue references only bind to rvalues.

Type deduction with lvalues and rvalues:

int x = 0; // `x` is an lvalue of type `int`
int& xl = x; // `xl` is an lvalue of type `int&`
int&& xr = x; // compiler error -- `x` is an lvalue
int&& xr2 = 0; // `xr2` is an lvalue of type `int&&` -- binds to the rvalue temporary, `0`

void f(int& x) {}
void f(int&& x) {}

f(x);  // calls f(int&)
f(xl); // calls f(int&)
f(3);  // calls f(int&&)
f(std::move(x)); // calls f(int&&)

f(xr2);           // calls f(int&)
f(std::move(xr2)); // calls f(int&& x)

§§§ Forwarding references

Also known (unofficially) as universal references. A forwarding reference is created with the syntax T&& where T is a template type parameter, or using auto&&. This enables perfect forwarding: the ability to pass arguments while maintaining their value category (e.g. lvalues stay as lvalues, temporaries are forwarded as rvalues).

Forwarding references allow a reference to bind to either an lvalue or rvalue depending on the type. Forwarding references follow the rules of reference collapsing:

T& & becomes T&
T& && becomes T&
T&& & becomes T&
T&& && becomes T&&

auto type deduction with lvalues and rvalues:

1
2
3

int x = 0; // `x` is an lvalue of type `int`
auto&& al = x; // `al` is an lvalue of type `int&` -- binds to the lvalue, `x`
auto&& ar = 0; // `ar` is an lvalue of type `int&&` -- binds to the rvalue temporary, `0`

Template type parameter deduction with lvalues and rvalues:

// Since C++14 or later:
void f(auto&& t) {
  // ...
}

// Since C++11 or later:
template <typename T>
void f(T&& t) {
  // ...
}

int x = 0;
f(0); // T is int, deduces as f(int &&) => f(int&&)
f(x); // T is int&, deduces as f(int& &&) => f(int&)

int& y = x;
f(y); // T is int&, deduces as f(int& &&) => f(int&)

int&& z = 0; // NOTE: `z` is an lvalue with type `int&&`.
f(z); // T is int&, deduces as f(int& &&) => f(int&)
f(std::move(z)); // T is int, deduces as f(int &&) => f(int&&)

§§§ Variadic templates

The ... syntax creates a parameter pack or expands one. A template parameter pack is a template parameter that accepts zero or more template arguments (non-types, types, or templates). A template with at least one parameter pack is called a variadic template.

template <typename... T>
struct arity {
  constexpr static int value = sizeof...(T);
};
static_assert(arity<>::value == 0);
static_assert(arity<char, short, int>::value == 3);

An interesting use for this is creating an initializer list from a parameter pack in order to iterate over variadic function arguments.

template <typename First, typename... Args>
auto sum(const First first, const Args... args) -> decltype(first) {
  const auto values = {first, args...};
  return std::accumulate(values.begin(), values.end(), First{0});
}

sum(1, 2, 3, 4, 5); // 15
sum(1, 2, 3);       // 6
sum(1.5, 2.0, 3.7); // 7.2

§§§ Initializer lists

A lightweight array-like container of elements created using a “braced list” syntax. For example, { 1, 2, 3 } creates a sequences of integers, that has type std::initializer_list<int>. Useful as a replacement to passing a vector of objects to a function.

int sum(const std::initializer_list<int>& list) {
  int total = 0;
  for (auto& e : list) {
    total += e;
  }

  return total;
}

auto list = {1, 2, 3};
sum(list); // == 6
sum({1, 2, 3}); // == 6
sum({}); // == 0

§§§ Static assertions

Assertions that are evaluated at compile-time.

1
2
3

constexpr int x = 0;
constexpr int y = 1;
static_assert(x == y, "x != y");

§§§ auto

auto-typed variables are deduced by the compiler according to the type of their initializer.

auto a = 3.14; // double
auto b = 1; // int
auto& c = b; // int&
auto d = { 0 }; // std::initializer_list<int>
auto&& e = 1; // int&&
auto&& f = b; // int&
auto g = new auto(123); // int*
const auto h = 1; // const int
auto i = 1, j = 2, k = 3; // int, int, int
auto l = 1, m = true, n = 1.61; // error -- `l` deduced to be int, `m` is bool
auto o; // error -- `o` requires initializer

Extremely useful for readability, especially for complicated types:

std::vector<int> v = ...;
std::vector<int>::const_iterator cit = v.cbegin();
// vs.
auto cit = v.cbegin();

Functions can also deduce the return type using auto. In C++11, a return type must be specified either explicitly, or using decltype like so:

template <typename X, typename Y>
auto add(X x, Y y) -> decltype(x + y) {
  return x + y;
}
add(1, 2); // == 3
add(1, 2.0); // == 3.0
add(1.5, 1.5); // == 3.0

The trailing return type in the above example is the declared type (see section on decltype) of the expression x + y. For example, if x is an integer and y is a double, decltype(x + y) is a double. Therefore, the above function will deduce the type depending on what type the expression x + y yields. Notice that the trailing return type has access to its parameters, and this when appropriate.

§§§ Lambda expressions

A lambda is an unnamed function object capable of capturing variables in scope. It features: a capture list; an optional set of parameters with an optional trailing return type; and a body. Examples of capture lists:

[] - captures nothing.
[=] - capture local objects (local variables, parameters) in scope by value.
[&] - capture local objects (local variables, parameters) in scope by reference.
[this] - capture this by reference.
[a, &b] - capture objects a by value, b by reference.

int x = 1;

auto getX = [=] { return x; };
getX(); // == 1

auto addX = [=](int y) { return x + y; };
addX(1); // == 2

auto getXRef = [&]() -> int& { return x; };
getXRef(); // int& to `x`

By default, value-captures cannot be modified inside the lambda because the compiler-generated method is marked as const. The mutable keyword allows modifying captured variables. The keyword is placed after the parameter-list (which must be present even if it is empty).

int x = 1;

auto f1 = [&x] { x = 2; }; // OK: x is a reference and modifies the original

auto f2 = [x] { x = 2; }; // ERROR: the lambda can only perform const-operations on the captured value
// vs.
auto f3 = [x]() mutable { x = 2; }; // OK: the lambda can perform any operations on the captured value

§§§ decltype

decltype is an operator which returns the declared type of an expression passed to it. cv-qualifiers and references are maintained if they are part of the expression. Examples of decltype:

int a = 1; // `a` is declared as type `int`
decltype(a) b = a; // `decltype(a)` is `int`
const int& c = a; // `c` is declared as type `const int&`
decltype(c) d = a; // `decltype(c)` is `const int&`
decltype(123) e = 123; // `decltype(123)` is `int`
int&& f = 1; // `f` is declared as type `int&&`
decltype(f) g = 1; // `decltype(f) is `int&&`
decltype((a)) h = g; // `decltype((a))` is int&

template <typename X, typename Y>
auto add(X x, Y y) -> decltype(x + y) {
  return x + y;
}
add(1, 2.0); // `decltype(x + y)` => `decltype(3.0)` => `double`

§§§ Type aliases

Semantically similar to using a typedef however, type aliases with using are easier to read and are compatible with templates.

template <typename T>
using Vec = std::vector<T>;
Vec<int> v; // std::vector<int>

using String = std::string;
String s {"foo"};

§§§ nullptr

C++11 introduces a new null pointer type designed to replace C’s NULL macro. nullptr itself is of type std::nullptr_t and can be implicitly converted into pointer types, and unlike NULL, not convertible to integral types except bool.

void foo(int);
void foo(char*);
foo(NULL); // error -- ambiguous
foo(nullptr); // calls foo(char*)

§§§ Strongly-typed enums

Type-safe enums that solve a variety of problems with C-style enums including: implicit conversions, inability to specify the underlying type, scope pollution.

// Specifying underlying type as `unsigned int`
enum class Color : unsigned int { Red = 0xff0000, Green = 0xff00, Blue = 0xff };
// `Red`/`Green` in `Alert` don't conflict with `Color`
enum class Alert : bool { Red, Green };
Color c = Color::Red;

§§§ Attributes

Attributes provide a universal syntax over __attribute__(...), __declspec, etc.

// `noreturn` attribute indicates `f` doesn't return.
[[ noreturn ]] void f() {
  throw "error";
}

§§§ constexpr

Constant expressions are expressions that are possibly evaluated by the compiler at compile-time. Only non-complex computations can be carried out in a constant expression (these rules are progressively relaxed in later versions). Use the constexpr specifier to indicate the variable, function, etc. is a constant expression.

constexpr int square(int x) {
  return x * x;
}

int square2(int x) {
  return x * x;
}

int a = square(2);  // mov DWORD PTR [rbp-4], 4

int b = square2(2); // mov edi, 2
                    // call square2(int)
                    // mov DWORD PTR [rbp-8], eax

In the previous snippet, notice that the computation when calling square is carried out at compile-time, and then the result is embedded in the code generation, while square2 is called at run-time.

constexpr values are those that the compiler can evaluate, but are not guaranteed to, at compile-time:

1
2

const int x = 123;
constexpr const int& y = x; // error -- constexpr variable `y` must be initialized by a constant expression

Constant expressions with classes:

struct Complex {
  constexpr Complex(double r, double i) : re{r}, im{i} { }
  constexpr double real() { return re; }
  constexpr double imag() { return im; }

private:
  double re;
  double im;
};

constexpr Complex I(0, 1);

§§§ Delegating constructors

Constructors can now call other constructors in the same class using an initializer list.

struct Foo {
  int foo;
  Foo(int foo) : foo{foo} {}
  Foo() : Foo(0) {}
};

Foo foo;
foo.foo; // == 0

§§§ User-defined literals

User-defined literals allow you to extend the language and add your own syntax. To create a literal, define a T operator "" X(...) { ... } function that returns a type T, with a name X. Note that the name of this function defines the name of the literal. Any literal names not starting with an underscore are reserved and won’t be invoked. There are rules on what parameters a user-defined literal function should accept, according to what type the literal is called on.

Converting Celsius to Fahrenheit:

// `unsigned long long` parameter required for integer literal.
long long operator "" _celsius(unsigned long long tempCelsius) {
  return std::llround(tempCelsius * 1.8 + 32);
}
24_celsius; // == 75

String to integer conversion:

// `const char*` and `std::size_t` required as parameters.
int operator "" _int(const char* str, std::size_t) {
  return std::stoi(str);
}

"123"_int; // == 123, with type `int`

§§§ Explicit virtual overrides

Specifies that a virtual function overrides another virtual function. If the virtual function does not override a parent’s virtual function, throws a compiler error.

struct A {
  virtual void foo();
  void bar();
};

struct B : A {
  void foo() override; // correct -- B::foo overrides A::foo
  void bar() override; // error -- A::bar is not virtual
  void baz() override; // error -- B::baz does not override A::baz
};

§§§ Final specifier

Specifies that a virtual function cannot be overridden in a derived class or that a class cannot be inherited from.

struct A {
  virtual void foo();
};

struct B : A {
  virtual void foo() final;
};

struct C : B {
  virtual void foo(); // error -- declaration of 'foo' overrides a 'final' function
};

Class cannot be inherited from.

1
2

struct A final {};
struct B : A {}; // error -- base 'A' is marked 'final'

§§§ Default functions

A more elegant, efficient way to provide a default implementation of a function, such as a constructor.

struct A {
  A() = default;
  A(int x) : x{x} {}
  int x {1};
};
A a; // a.x == 1
A a2 {123}; // a.x == 123

With inheritance:

struct B {
  B() : x{1} {}
  int x;
};

struct C : B {
  // Calls B::B
  C() = default;
};

C c; // c.x == 1

§§§ Deleted functions

A more elegant, efficient way to provide a deleted implementation of a function. Useful for preventing copies on objects.

class A {
  int x;

public:
  A(int x) : x{x} {};
  A(const A&) = delete;
  A& operator=(const A&) = delete;
};

A x {123};
A y = x; // error -- call to deleted copy constructor
y = x; // error -- operator= deleted

§§§ Range-based for loops

Syntactic sugar for iterating over a container’s elements.

1
2
3

std::array<int, 5> a {1, 2, 3, 4, 5};
for (int& x : a) x *= 2;
// a == { 2, 4, 6, 8, 10 }

Note the difference when using int as opposed to int&:

1
2
3

std::array<int, 5> a {1, 2, 3, 4, 5};
for (int x : a) x *= 2;
// a == { 1, 2, 3, 4, 5 }

§§§ Special member functions for move semantics

The copy constructor and copy assignment operator are called when copies are made, and with C++11’s introduction of move semantics, there is now a move constructor and move assignment operator for moves.

struct A {
  std::string s;
  A() : s{"test"} {}
  A(const A& o) : s{o.s} {}
  A(A&& o) : s{std::move(o.s)} {}
  A& operator=(A&& o) {
   s = std::move(o.s);
   return *this;
  }
};

A f(A a) {
  return a;
}

A a1 = f(A{}); // move-constructed from rvalue temporary
A a2 = std::move(a1); // move-constructed using std::move
A a3 = A{};
a2 = std::move(a3); // move-assignment using std::move
a1 = f(A{}); // move-assignment from rvalue temporary

§§§ Converting constructors

Converting constructors will convert values of braced list syntax into constructor arguments.

struct A {
  A(int) {}
  A(int, int) {}
  A(int, int, int) {}
};

A a {0, 0}; // calls A::A(int, int)
A b(0, 0); // calls A::A(int, int)
A c = {0, 0}; // calls A::A(int, int)
A d {0, 0, 0}; // calls A::A(int, int, int)

Note that the braced list syntax does not allow narrowing:

struct A {
  A(int) {}
};

A a(1.1); // OK
A b {1.1}; // Error narrowing conversion from double to int

Note that if a constructor accepts a std::initializer_list, it will be called instead:

struct A {
  A(int) {}
  A(int, int) {}
  A(int, int, int) {}
  A(std::initializer_list<int>) {}
};

A a {0, 0}; // calls A::A(std::initializer_list<int>)
A b(0, 0); // calls A::A(int, int)
A c = {0, 0}; // calls A::A(std::initializer_list<int>)
A d {0, 0, 0}; // calls A::A(std::initializer_list<int>)

§§§ Explicit conversion functions

Conversion functions can now be made explicit using the explicit specifier.

struct A {
  operator bool() const { return true; }
};

struct B {
  explicit operator bool() const { return true; }
};

A a;
if (a); // OK calls A::operator bool()
bool ba = a; // OK copy-initialization selects A::operator bool()

B b;
if (b); // OK calls B::operator bool()
bool bb = b; // error copy-initialization does not consider B::operator bool()

§§§ Inline namespaces

All members of an inline namespace are treated as if they were part of its parent namespace, allowing specialization of functions and easing the process of versioning. This is a transitive property, if A contains B, which in turn contains C and both B and C are inline namespaces, C’s members can be used as if they were on A.

namespace Program {
  namespace Version1 {
    int getVersion() { return 1; }
    bool isFirstVersion() { return true; }
  }
  inline namespace Version2 {
    int getVersion() { return 2; }
  }
}

int version {Program::getVersion()};              // Uses getVersion() from Version2
int oldVersion {Program::Version1::getVersion()}; // Uses getVersion() from Version1
bool firstVersion {Program::isFirstVersion()};    // Does not compile when Version2 is added

§§§ Non-static data member initializers

Allows non-static data members to be initialized where they are declared, potentially cleaning up constructors of default initializations.

// Default initialization prior to C++11
class Human {
    Human() : age{0} {}
  private:
    unsigned age;
};
// Default initialization on C++11
class Human {
  private:
    unsigned age {0};
};

§§§ Right angle brackets

C++11 is now able to infer when a series of right angle brackets is used as an operator or as a closing statement of typedef, without having to add whitespace.

1
2

typedef std::map<int, std::map <int, std::map <int, int> > > cpp98LongTypedef;
typedef std::map<int, std::map <int, std::map <int, int>>>   cpp11LongTypedef;

§§§ Ref-qualified member functions

Member functions can now be qualified depending on whether *this is an lvalue or rvalue reference.

struct Bar {
  // ...
};

struct Foo {
  Bar& getBar() & { return bar; }
  const Bar& getBar() const& { return bar; }
  Bar&& getBar() && { return std::move(bar); }
  const Bar&& getBar() const&& { return std::move(bar); }
private:
  Bar bar;
};

Foo foo{};
Bar bar = foo.getBar(); // calls `Bar& getBar() &`

const Foo foo2{};
Bar bar2 = foo2.getBar(); // calls `Bar& Foo::getBar() const&`

Foo{}.getBar(); // calls `Bar&& Foo::getBar() &&`
std::move(foo).getBar(); // calls `Bar&& Foo::getBar() &&`
std::move(foo2).getBar(); // calls `const Bar&& Foo::getBar() const&`

§§§ Trailing return types

C++11 allows functions and lambdas an alternative syntax for specifying their return types.

int f() {
  return 123;
}
// vs.
auto f() -> int {
  return 123;
}

1
2
3

auto g = []() -> int {
  return 123;
};

This feature is especially useful when certain return types cannot be resolved:

// NOTE: This does not compile!
template <typename T, typename U>
decltype(a + b) add(T a, U b) {
    return a + b;
}

// Trailing return types allows this:
template <typename T, typename U>
auto add(T a, U b) -> decltype(a + b) {
    return a + b;
}

In C++14, decltype(auto) (C++14) can be used instead.

§§§ Noexcept specifier

The noexcept specifier specifies whether a function could throw exceptions. It is an improved version of throw().

void func1() noexcept;        // does not throw
void func2() noexcept(true);  // does not throw
void func3() throw();         // does not throw

void func4() noexcept(false); // may throw

Non-throwing functions are permitted to call potentially-throwing functions. Whenever an exception is thrown and the search for a handler encounters the outermost block of a non-throwing function, the function std::terminate is called.

extern void f();  // potentially-throwing
void g() noexcept {
    f();          // valid, even if f throws
    throw 42;     // valid, effectively a call to std::terminate
}

§§§ char32_t and char16_t

Provides standard types for representing UTF-8 strings.

1
2

char32_t utf8_str[] = U"\u0123";
char16_t utf8_str[] = u"\u0123";

§§§ Raw string literals

C++11 introduces a new way to declare string literals as “raw string literals”. Characters issued from an escape sequence (tabs, line feeds, single backslashes, etc.) can be inputted raw while preserving formatting. This is useful, for example, to write literary text, which might contain a lot of quotes or special formatting. This can make your string literals easier to read and maintain.

A raw string literal is declared using the following syntax:

R"delimiter(raw_characters)delimiter"

where:

delimiter is an optional sequence of characters made of any source character except parentheses, backslashes and spaces.
raw_characters is any raw character sequence; must not contain the closing sequence ")delimiter".

Example:

// msg1 and msg2 are equivalent.
const char* msg1 = "\nHello,\n\tworld!\n";
const char* msg2 = R"(
Hello,
	world!
)";

§§ C++11 Library Features

§§§ std::move

std::move indicates that the object passed to it may have its resources transferred. Using objects that have been moved from should be used with care, as they can be left in an unspecified state (see: What can I do with a moved-from object?).

A definition of std::move (performing a move is nothing more than casting to an rvalue reference):

template <typename T>
typename remove_reference<T>::type&& move(T&& arg) {
  return static_cast<typename remove_reference<T>::type&&>(arg);
}

Transferring std::unique_ptrs:

std::unique_ptr<int> p1 {new int{0}};  // in practice, use std::make_unique
std::unique_ptr<int> p2 = p1; // error -- cannot copy unique pointers
std::unique_ptr<int> p3 = std::move(p1); // move `p1` into `p3`
                                         // now unsafe to dereference object held by `p1`

§§§ std::forward

Returns the arguments passed to it while maintaining their value category and cv-qualifiers. Useful for generic code and factories. Used in conjunction with forwarding references.

A definition of std::forward:

template <typename T>
T&& forward(typename remove_reference<T>::type& arg) {
  return static_cast<T&&>(arg);
}

An example of a function wrapper which just forwards other A objects to a new A object’s copy or move constructor:

struct A {
  A() = default;
  A(const A& o) { std::cout << "copied" << std::endl; }
  A(A&& o) { std::cout << "moved" << std::endl; }
};

template <typename T>
A wrapper(T&& arg) {
  return A{std::forward<T>(arg)};
}

wrapper(A{}); // moved
A a;
wrapper(a); // copied
wrapper(std::move(a)); // moved

§§§ std::thread

The std::thread library provides a standard way to control threads, such as spawning and killing them. In the example below, multiple threads are spawned to do different calculations and then the program waits for all of them to finish.

void foo(bool clause) { /* do something... */ }

std::vector<std::thread> threadsVector;
threadsVector.emplace_back([]() {
  // Lambda function that will be invoked
});
threadsVector.emplace_back(foo, true);  // thread will run foo(true)
for (auto& thread : threadsVector) {
  thread.join(); // Wait for threads to finish
}

§§§ std::to_string

Converts a numeric argument to a std::string.

1
2

std::to_string(1.2); // == "1.2"
std::to_string(123); // == "123"

§§§ Type traits

Type traits defines a compile-time template-based interface to query or modify the properties of types.

1
2
3

static_assert(std::is_integral<int>::value);
static_assert(std::is_same<int, int>::value);
static_assert(std::is_same<std::conditional<true, int, double>::type, int>::value);

§§§ Smart pointers

C++11 introduces new smart pointers: std::unique_ptr, std::shared_ptr, std::weak_ptr. std::auto_ptr now becomes deprecated and then eventually removed in C++17.

std::unique_ptr is a non-copyable, movable pointer that manages its own heap-allocated memory. Note: Prefer using the std::make_X helper functions as opposed to using constructors. See the sections for std::make_unique and std::make_shared.

std::unique_ptr<Foo> p1 { new Foo{} };  // `p1` owns `Foo`
if (p1) {
  p1->bar();
}

{
  std::unique_ptr<Foo> p2 {std::move(p1)};  // Now `p2` owns `Foo`
  f(*p2);

  p1 = std::move(p2);  // Ownership returns to `p1` -- `p2` gets destroyed
}

if (p1) {
  p1->bar();
}
// `Foo` instance is destroyed when `p1` goes out of scope

A std::shared_ptr is a smart pointer that manages a resource that is shared across multiple owners. A shared pointer holds a control block which has a few components such as the managed object and a reference counter. All control block access is thread-safe, however, manipulating the managed object itself is not thread-safe.

void foo(std::shared_ptr<T> t) {
  // Do something with `t`...
}

void bar(std::shared_ptr<T> t) {
  // Do something with `t`...
}

void baz(std::shared_ptr<T> t) {
  // Do something with `t`...
}

std::shared_ptr<T> p1 {new T{}};
// Perhaps these take place in another threads?
foo(p1);
bar(p1);
baz(p1);

§§§ std::chrono

The chrono library contains a set of utility functions and types that deal with durations, clocks, and time points. One use case of this library is benchmarking code:

std::chrono::time_point<std::chrono::steady_clock> start, end;
start = std::chrono::steady_clock::now();
// Some computations...
end = std::chrono::steady_clock::now();

std::chrono::duration<double> elapsed_seconds = end - start;
double t = elapsed_seconds.count(); // t number of seconds, represented as a `double`

§§§ Tuples

Tuples are a fixed-size collection of heterogeneous values. Access the elements of a std::tuple by unpacking using std::tie, or using std::get.

// `playerProfile` has type `std::tuple<int, const char*, const char*>`.
auto playerProfile = std::make_tuple(51, "Frans Nielsen", "NYI");
std::get<0>(playerProfile); // 51
std::get<1>(playerProfile); // "Frans Nielsen"
std::get<2>(playerProfile); // "NYI"

§§§ std::tie

Creates a tuple of lvalue references. Useful for unpacking std::pair and std::tuple objects. Use std::ignore as a placeholder for ignored values. In C++17, structured bindings should be used instead.

// With tuples...
std::string playerName;
std::tie(std::ignore, playerName, std::ignore) = std::make_tuple(91, "John Tavares", "NYI");

// With pairs...
std::string yes, no;
std::tie(yes, no) = std::make_pair("yes", "no");

§§§ std::array

std::array is a container built on top of a C-style array. Supports common container operations such as sorting.

1
2
3

std::array<int, 3> a = {2, 1, 3};
std::sort(a.begin(), a.end()); // a == { 1, 2, 3 }
for (int& x : a) x *= 2; // a == { 2, 4, 6 }

§§§ Unordered containers

These containers maintain average constant-time complexity for search, insert, and remove operations. In order to achieve constant-time complexity, sacrifices order for speed by hashing elements into buckets. There are four unordered containers:

unordered_set
unordered_multiset
unordered_map
unordered_multimap

§§§ std::make_shared

std::make_shared is the recommended way to create instances of std::shared_ptrs due to the following reasons:

Avoid having to use the new operator.
Prevents code repetition when specifying the underlying type the pointer shall hold.
It provides exception-safety. Suppose we were calling a function foo like so:

`1`	`foo(std::shared_ptr<T>{new T{}}, function_that_throws(), std::shared_ptr<T>{new T{}});`

The compiler is free to call new T{}, then function_that_throws(), and so on… Since we have allocated data on the heap in the first construction of a T, we have introduced a leak here. With std::make_shared, we are given exception-safety:

`1`	`foo(std::make_shared<T>(), function_that_throws(), std::make_shared<T>());`

Prevents having to do two allocations. When calling std::shared_ptr{ new T{} }, we have to allocate memory for T, then in the shared pointer we have to allocate memory for the control block within the pointer.

See the section on smart pointers for more information on std::unique_ptr and std::shared_ptr.

§§§ std::ref

std::ref(val) is used to create object of type std::reference_wrapper that holds reference of val. Used in cases when usual reference passing using & does not compile or & is dropped due to type deduction. std::cref is similar but created reference wrapper holds a const reference to val.

// create a container to store reference of objects.
auto val = 99;
auto _ref = std::ref(val);
_ref++;
auto _cref = std::cref(val);
//_cref++; does not compile
std::vector<std::reference_wrapper<int>>vec; // vector<int&>vec does not compile
vec.push_back(_ref); // vec.push_back(&i) does not compile
cout << val << endl; // prints 100
cout << vec[0] << endl; // prints 100
cout << _cref; // prints 100

§§§ Memory model

C++11 introduces a memory model for C++, which means library support for threading and atomic operations. Some of these operations include (but aren’t limited to) atomic loads/stores, compare-and-swap, atomic flags, promises, futures, locks, and condition variables.

See the sections on: std::thread

§§§ std::async

std::async runs the given function either asynchronously or lazily-evaluated, then returns a std::future which holds the result of that function call.

The first parameter is the policy which can be:

std::launch::async | std::launch::deferred It is up to the implementation whether to perform asynchronous execution or lazy evaluation.
std::launch::async Run the callable object on a new thread.
std::launch::deferred Perform lazy evaluation on the current thread.

int foo() {
  /* Do something here, then return the result. */
  return 1000;
}

auto handle = std::async(std::launch::async, foo);  // create an async task
auto result = handle.get();  // wait for the result

§§§ std::begin/end

std::begin and std::end free functions were added to return begin and end iterators of a container generically. These functions also work with raw arrays which do not have begin and end member functions.

template <typename T>
int CountTwos(const T& container) {
  return std::count_if(std::begin(container), std::end(container), [](int item) {
    return item == 2;
  });
}

std::vector<int> vec = {2, 2, 43, 435, 4543, 534};
int arr[8] = {2, 43, 45, 435, 32, 32, 32, 32};
auto a = CountTwos(vec); // 2
auto b = CountTwos(arr);  // 1

§§ Acknowledgements

cppreference - especially useful for finding examples and documentation of new library features.
C++ Rvalue References Explained - a great introduction I used to understand rvalue references, perfect forwarding, and move semantics.
clang and gcc’s standards support pages. Also included here are the proposals for language/library features that I used to help find a description of, what it’s meant to fix, and some examples.
Compiler explorer
Scott Meyers’ Effective Modern C++ - highly recommended book!
Jason Turner’s C++ Weekly - nice collection of C++-related videos.
What can I do with a moved-from object?
What are some uses of decltype(auto)?
And many more SO posts I’m forgetting…

§ COPYING & ATTRIBUTIONS:

Author Anthony Calandra
Content Contributors See: https://github.com/AnthonyCalandra/modern-cpp-features/graphs/contributors
License: The MIT License (MIT) Copyright (c) 2024 Anthony Calandra

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

modern cpp features - C++14

i@shrik3.com (SHRIK3) — Sun, 15 Dec 2024 20:43:04 +0100

§ C++14

§§ Overview

Many of these descriptions and examples are taken from various resources (see Acknowledgements section) and summarized in my own words.

C++14 includes the following new language features:

C++14 includes the following new library features:

§§ C++14 Language Features

§§§ Binary literals

Binary literals provide a convenient way to represent a base-2 number. It is possible to separate digits with '.

1
2

0b110 // == 6
0b1111'1111 // == 255

§§§ Generic lambda expressions

C++14 now allows the auto type-specifier in the parameter list, enabling polymorphic lambdas.

1
2
3

auto identity = [](auto x) { return x; };
int three = identity(3); // == 3
std::string foo = identity("foo"); // == "foo"

§§§ Lambda capture initializers

This allows creating lambda captures initialized with arbitrary expressions. The name given to the captured value does not need to be related to any variables in the enclosing scopes and introduces a new name inside the lambda body. The initializing expression is evaluated when the lambda is created (not when it is invoked).

int factory(int i) { return i * 10; }
auto f = [x = factory(2)] { return x; }; // returns 20

auto generator = [x = 0] () mutable {
  // this would not compile without 'mutable' as we are modifying x on each call
  return x++;
};
auto a = generator(); // == 0
auto b = generator(); // == 1
auto c = generator(); // == 2

Because it is now possible to move (or forward) values into a lambda that could previously be only captured by copy or reference we can now capture move-only types in a lambda by value. Note that in the below example the p in the capture-list of task2 on the left-hand-side of = is a new variable private to the lambda body and does not refer to the original p.

auto p = std::make_unique<int>(1);

auto task1 = [=] { *p = 5; }; // ERROR: std::unique_ptr cannot be copied
// vs.
auto task2 = [p = std::move(p)] { *p = 5; }; // OK: p is move-constructed into the closure object
// the original p is empty after task2 is created

Using this reference-captures can have different names than the referenced variable.

auto x = 1;
auto f = [&r = x, x = x * 10] {
  ++r;
  return r + x;
};
f(); // sets x to 2 and returns 12

§§§ Return type deduction

Using an auto return type in C++14, the compiler will attempt to deduce the type for you. With lambdas, you can now deduce its return type using auto, which makes returning a deduced reference or rvalue reference possible.

// Deduce return type as `int`.
auto f(int i) {
 return i;
}

template <typename T>
auto& f(T& t) {
  return t;
}

// Returns a reference to a deduced type.
auto g = [](auto& x) -> auto& { return f(x); };
int y = 123;
int& z = g(y); // reference to `y`

§§§ decltype(auto)

The decltype(auto) type-specifier also deduces a type like auto does. However, it deduces return types while keeping their references and cv-qualifiers, while auto will not.

const int x = 0;
auto x1 = x; // int
decltype(auto) x2 = x; // const int
int y = 0;
int& y1 = y;
auto y2 = y1; // int
decltype(auto) y3 = y1; // int&
int&& z = 0;
auto z1 = std::move(z); // int
decltype(auto) z2 = std::move(z); // int&&

// Note: Especially useful for generic code!

// Return type is `int`.
auto f(const int& i) {
 return i;
}

// Return type is `const int&`.
decltype(auto) g(const int& i) {
 return i;
}

int x = 123;
static_assert(std::is_same<const int&, decltype(f(x))>::value == 0);
static_assert(std::is_same<int, decltype(f(x))>::value == 1);
static_assert(std::is_same<const int&, decltype(g(x))>::value == 1);

§§§ Relaxing constraints on constexpr functions

In C++11, constexpr function bodies could only contain a very limited set of syntaxes, including (but not limited to): typedefs, usings, and a single return statement. In C++14, the set of allowable syntaxes expands greatly to include the most common syntax such as if statements, multiple returns, loops, etc.

constexpr int factorial(int n) {
  if (n <= 1) {
    return 1;
  } else {
    return n * factorial(n - 1);
  }
}
factorial(5); // == 120

§§§ Variable templates

C++14 allows variables to be templated:

template<class T>
constexpr T pi = T(3.1415926535897932385);
template<class T>
constexpr T e  = T(2.7182818284590452353);

§§§ [[deprecated]] attribute

C++14 introduces the [[deprecated]] attribute to indicate that a unit (function, class, etc.) is discouraged and likely yield compilation warnings. If a reason is provided, it will be included in the warnings.

[[deprecated]]
void old_method();
[[deprecated("Use new_method instead")]]
void legacy_method();

§§ C++14 Library Features

§§§ User-defined literals for standard library types

New user-defined literals for standard library types, including new built-in literals for chrono and basic_string. These can be constexpr meaning they can be used at compile-time. Some uses for these literals include compile-time integer parsing, binary literals, and imaginary number literals.

using namespace std::chrono_literals;
auto day = 24h;
day.count(); // == 24
std::chrono::duration_cast<std::chrono::minutes>(day).count(); // == 1440

§§§ Compile-time integer sequences

The class template std::integer_sequence represents a compile-time sequence of integers. There are a few helpers built on top:

std::make_integer_sequence<T, N> - creates a sequence of 0, ..., N - 1 with type T.
std::index_sequence_for<T...> - converts a template parameter pack into an integer sequence.

Convert an array into a tuple:

template<typename Array, std::size_t... I>
decltype(auto) a2t_impl(const Array& a, std::integer_sequence<std::size_t, I...>) {
  return std::make_tuple(a[I]...);
}

template<typename T, std::size_t N, typename Indices = std::make_index_sequence<N>>
decltype(auto) a2t(const std::array<T, N>& a) {
  return a2t_impl(a, Indices());
}

§§§ std::make_unique

std::make_unique is the recommended way to create instances of std::unique_ptrs due to the following reasons:

Avoid having to use the new operator.
Prevents code repetition when specifying the underlying type the pointer shall hold.
Most importantly, it provides exception-safety. Suppose we were calling a function foo like so:

`1`	`foo(std::unique_ptr<T>{new T{}}, function_that_throws(), std::unique_ptr<T>{new T{}});`

`1`	`foo(std::make_unique<T>(), function_that_throws(), std::make_unique<T>());`

See the section on smart pointers (C++11) for more information on std::unique_ptr and std::shared_ptr.

§§ Acknowledgements

cppreference - especially useful for finding examples and documentation of new library features.
C++ Rvalue References Explained - a great introduction I used to understand rvalue references, perfect forwarding, and move semantics.
clang and gcc’s standards support pages. Also included here are the proposals for language/library features that I used to help find a description of, what it’s meant to fix, and some examples.
Compiler explorer
Scott Meyers’ Effective Modern C++ - highly recommended book!
Jason Turner’s C++ Weekly - nice collection of C++-related videos.
What can I do with a moved-from object?
What are some uses of decltype(auto)?
And many more SO posts I’m forgetting…

§ COPYING & ATTRIBUTIONS:

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

modern cpp features - C++17

i@shrik3.com (SHRIK3) — Sun, 15 Dec 2024 20:43:04 +0100

§ C++17

§§ Overview

Many of these descriptions and examples are taken from various resources (see Acknowledgements section) and summarized in my own words.

C++17 includes the following new language features:

C++17 includes the following new library features:

§§ C++17 Language Features

§§§ Template argument deduction for class templates

Automatic template argument deduction much like how it’s done for functions, but now including class constructors.

template <typename T = float>
struct MyContainer {
  T val;
  MyContainer() : val{} {}
  MyContainer(T val) : val{val} {}
  // ...
};
MyContainer c1 {1}; // OK MyContainer<int>
MyContainer c2; // OK MyContainer<float>

§§§ Declaring non-type template parameters with auto

Following the deduction rules of auto, while respecting the non-type template parameter list of allowable types[*], template arguments can be deduced from the types of its arguments:

template <auto... seq>
struct my_integer_sequence {
  // Implementation here ...
};

// Explicitly pass type `int` as template argument.
auto seq = std::integer_sequence<int, 0, 1, 2>();
// Type is deduced to be `int`.
auto seq2 = my_integer_sequence<0, 1, 2>();

* - For example, you cannot use a double as a template parameter type, which also makes this an invalid deduction using auto.

§§§ Folding expressions

A fold expression performs a fold of a template parameter pack over a binary operator.

An expression of the form (... op e) or (e op ...), where op is a fold-operator and e is an unexpanded parameter pack, are called unary folds.
An expression of the form (e1 op ... op e2), where op are fold-operators, is called a binary fold. Either e1 or e2 is an unexpanded parameter pack, but not both.

template <typename... Args>
bool logicalAnd(Args... args) {
    // Binary folding.
    return (true && ... && args);
}
bool b = true;
bool& b2 = b;
logicalAnd(b, b2, true); // == true

template <typename... Args>
auto sum(Args... args) {
    // Unary folding.
    return (... + args);
}
sum(1.0, 2.0f, 3); // == 6.0

§§§ New rules for auto deduction from braced-init-list

Changes to auto deduction when used with the uniform initialization syntax. Previously, auto x {3}; deduces a std::initializer_list<int>, which now deduces to int.

auto x1 {1, 2, 3}; // error: not a single element
auto x2 = {1, 2, 3}; // x2 is std::initializer_list<int>
auto x3 {3}; // x3 is int
auto x4 {3.0}; // x4 is double

§§§ constexpr lambda

Compile-time lambdas using constexpr.

1
2

auto identity = [](int n) constexpr { return n; };
static_assert(identity(123) == 123);

constexpr auto add = [](int x, int y) {
  auto L = [=] { return x; };
  auto R = [=] { return y; };
  return [=] { return L() + R(); };
};

static_assert(add(1, 2)() == 3);

constexpr int addOne(int n) {
  return [n] { return n + 1; }();
}

static_assert(addOne(1) == 2);

§§§ Lambda capture `this` by value

Capturing this in a lambda’s environment was previously reference-only. An example of where this is problematic is asynchronous code using callbacks that require an object to be available, potentially past its lifetime. *this (C++17) will now make a copy of the current object, while this (C++11) continues to capture by reference.

struct MyObj {
  int value {123};
  auto getValueCopy() {
    return [*this] { return value; };
  }
  auto getValueRef() {
    return [this] { return value; };
  }
};
MyObj mo;
auto valueCopy = mo.getValueCopy();
auto valueRef = mo.getValueRef();
mo.value = 321;
valueCopy(); // 123
valueRef(); // 321

§§§ Inline variables

The inline specifier can be applied to variables as well as to functions. A variable declared inline has the same semantics as a function declared inline.

// Disassembly example using compiler explorer.
struct S { int x; };
inline S x1 = S{321}; // mov esi, dword ptr [x1]
                      // x1: .long 321

S x2 = S{123};        // mov eax, dword ptr [.L_ZZ4mainE2x2]
                      // mov dword ptr [rbp - 8], eax
                      // .L_ZZ4mainE2x2: .long 123

It can also be used to declare and define a static member variable, such that it does not need to be initialized in the source file.

struct S {
  S() : id{count++} {}
  ~S() { count--; }
  int id;
  static inline int count{0}; // declare and initialize count to 0 within the class
};

§§§ Nested namespaces

Using the namespace resolution operator to create nested namespace definitions.

namespace A {
  namespace B {
    namespace C {
      int i;
    }
  }
}

The code above can be written like this:

1
2
3

namespace A::B::C {
  int i;
}

§§§ Structured bindings

A proposal for de-structuring initialization, that would allow writing auto [ x, y, z ] = expr; where the type of expr was a tuple-like object, whose elements would be bound to the variables x, y, and z (which this construct declares). Tuple-like objects include std::tuple, std::pair, std::array, and aggregate structures.

using Coordinate = std::pair<int, int>;
Coordinate origin() {
  return Coordinate{0, 0};
}

const auto [ x, y ] = origin();
x; // == 0
y; // == 0

std::unordered_map<std::string, int> mapping {
  {"a", 1},
  {"b", 2},
  {"c", 3}
};

// Destructure by reference.
for (const auto& [key, value] : mapping) {
  // Do something with key and value
}

§§§ Selection statements with initializer

New versions of the if and switch statements which simplify common code patterns and help users keep scopes tight.

{
  std::lock_guard<std::mutex> lk(mx);
  if (v.empty()) v.push_back(val);
}
// vs.
if (std::lock_guard<std::mutex> lk(mx); v.empty()) {
  v.push_back(val);
}

Foo gadget(args);
switch (auto s = gadget.status()) {
  case OK: gadget.zip(); break;
  case Bad: throw BadFoo(s.message());
}
// vs.
switch (Foo gadget(args); auto s = gadget.status()) {
  case OK: gadget.zip(); break;
  case Bad: throw BadFoo(s.message());
}

§§§ constexpr if

Write code that is instantiated depending on a compile-time condition.

template <typename T>
constexpr bool isIntegral() {
  if constexpr (std::is_integral<T>::value) {
    return true;
  } else {
    return false;
  }
}
static_assert(isIntegral<int>() == true);
static_assert(isIntegral<char>() == true);
static_assert(isIntegral<double>() == false);
struct S {};
static_assert(isIntegral<S>() == false);

§§§ UTF-8 character literals

A character literal that begins with u8 is a character literal of type char. The value of a UTF-8 character literal is equal to its ISO 10646 code point value.

`1`	`char x = u8'x';`

§§§ Direct list initialization of enums

Enums can now be initialized using braced syntax.

enum byte : unsigned char {};
byte b {0}; // OK
byte c {-1}; // ERROR
byte d = byte{1}; // OK
byte e = byte{256}; // ERROR

§§§ [[fallthrough]], [[nodiscard]], [[maybe_unused]] attributes

C++17 introduces three new attributes: [[fallthrough]], [[nodiscard]] and [[maybe_unused]].

[[fallthrough]] indicates to the compiler that falling through in a switch statement is intended behavior. This attribute may only be used in a switch statement, and must be placed before the next case/default label.

switch (n) {
  case 1: 
    // ...
    [[fallthrough]];
  case 2:
    // ...
    break;
  case 3:
    // ...
    [[fallthrough]];
  default:
    // ...
}

[[nodiscard]] issues a warning when either a function or class has this attribute and its return value is discarded.

[[nodiscard]] bool do_something() {
  return is_success; // true for success, false for failure
}

do_something(); // warning: ignoring return value of 'bool do_something()',
                // declared with attribute 'nodiscard'

// Only issues a warning when `error_info` is returned by value.
struct [[nodiscard]] error_info {
  // ...
};

error_info do_something() {
  error_info ei;
  // ...
  return ei;
}

do_something(); // warning: ignoring returned value of type 'error_info',
                // declared with attribute 'nodiscard'

[[maybe_unused]] indicates to the compiler that a variable or parameter might be unused and is intended.

void my_callback(std::string msg, [[maybe_unused]] bool error) {
  // Don't care if `msg` is an error message, just log it.
  log(msg);
}

§§§ __has_include

__has_include (operand) operator may be used in #if and #elif expressions to check whether a header or source file (operand) is available for inclusion or not.

One use case of this would be using two libraries that work the same way, using the backup/experimental one if the preferred one is not found on the system.

#ifdef __has_include
#  if __has_include(<optional>)
#    include <optional>
#    define have_optional 1
#  elif __has_include(<experimental/optional>)
#    include <experimental/optional>
#    define have_optional 1
#    define experimental_optional
#  else
#    define have_optional 0
#  endif
#endif

It can also be used to include headers existing under different names or locations on various platforms, without knowing which platform the program is running on, OpenGL headers are a good example for this which are located in OpenGL\ directory on macOS and GL\ on other platforms.

#ifdef __has_include
#  if __has_include(<OpenGL/gl.h>)
#    include <OpenGL/gl.h>
#    include <OpenGL/glu.h>
#  elif __has_include(<GL/gl.h>)
#    include <GL/gl.h>
#    include <GL/glu.h>
#  else
#    error No suitable OpenGL headers found.
# endif
#endif

§§§ Class template argument deduction

Class template argument deduction (CTAD) allows the compiler to deduce template arguments from constructor arguments.

std::vector v{ 1, 2, 3 }; // deduces std::vector<int>

std::mutex mtx;
auto lck = std::lock_guard{ mtx }; // deduces to std::lock_guard<std::mutex>

auto p = new std::pair{ 1.0, 2.0 }; // deduces to std::pair<double, double>*

For user-defined types, deduction guides can be used to guide the compiler how to deduce template arguments if applicable:

template <typename T>
struct container {
  container(T t) {}

  template <typename Iter>
  container(Iter beg, Iter end);
};

// deduction guide
template <typename Iter>
container(Iter b, Iter e) -> container<typename std::iterator_traits<Iter>::value_type>;

container a{ 7 }; // OK: deduces container<int>

std::vector<double> v{ 1.0, 2.0, 3.0 };
auto b = container{ v.begin(), v.end() }; // OK: deduces container<double>

container c{ 5, 6 }; // ERROR: std::iterator_traits<int>::value_type is not a type

§§ C++17 Library Features

§§§ std::variant

The class template std::variant represents a type-safe union. An instance of std::variant at any given time holds a value of one of its alternative types (it’s also possible for it to be valueless).

std::variant<int, double> v{ 12 };
std::get<int>(v); // == 12
std::get<0>(v); // == 12
v = 12.0;
std::get<double>(v); // == 12.0
std::get<1>(v); // == 12.0

§§§ std::optional

The class template std::optional manages an optional contained value, i.e. a value that may or may not be present. A common use case for optional is the return value of a function that may fail.

std::optional<std::string> create(bool b) {
  if (b) {
    return "Godzilla";
  } else {
    return {};
  }
}

create(false).value_or("empty"); // == "empty"
create(true).value(); // == "Godzilla"
// optional-returning factory functions are usable as conditions of while and if
if (auto str = create(true)) {
  // ...
}

§§§ std::any

A type-safe container for single values of any type.

std::any x {5};
x.has_value() // == true
std::any_cast<int>(x) // == 5
std::any_cast<int&>(x) = 10;
std::any_cast<int>(x) // == 10

§§§ std::string_view

A non-owning reference to a string. Useful for providing an abstraction on top of strings (e.g. for parsing).

// Regular strings.
std::string_view cppstr {"foo"};
// Wide strings.
std::wstring_view wcstr_v {L"baz"};
// Character arrays.
char array[3] = {'b', 'a', 'r'};
std::string_view array_v(array, std::size(array));

std::string str {"   trim me"};
std::string_view v {str};
v.remove_prefix(std::min(v.find_first_not_of(" "), v.size()));
str; //  == "   trim me"
v; // == "trim me"

§§§ std::invoke

Invoke a Callable object with parameters. Examples of callable objects are std::function or lambdas; objects that can be called similarly to a regular function.

template <typename Callable>
class Proxy {
  Callable c_;

public:
  Proxy(Callable c) : c_{ std::move(c) } {}

  template <typename... Args>
  decltype(auto) operator()(Args&&... args) {
    // ...
    return std::invoke(c_, std::forward<Args>(args)...);
  }
};

const auto add = [](int x, int y) { return x + y; };
Proxy p{ add };
p(1, 2); // == 3

§§§ std::apply

Invoke a Callable object with a tuple of arguments.

auto add = [](int x, int y) {
  return x + y;
};
std::apply(add, std::make_tuple(1, 2)); // == 3

§§§ std::filesystem

The new std::filesystem library provides a standard way to manipulate files, directories, and paths in a filesystem.

Here, a big file is copied to a temporary path if there is available space:

const auto bigFilePath {"bigFileToCopy"};
if (std::filesystem::exists(bigFilePath)) {
  const auto bigFileSize {std::filesystem::file_size(bigFilePath)};
  std::filesystem::path tmpPath {"/tmp"};
  if (std::filesystem::space(tmpPath).available > bigFileSize) {
    std::filesystem::create_directory(tmpPath.append("example"));
    std::filesystem::copy_file(bigFilePath, tmpPath.append("newFile"));
  }
}

§§§ std::byte

The new std::byte type provides a standard way of representing data as a byte. Benefits of using std::byte over char or unsigned char is that it is not a character type, and is also not an arithmetic type; while the only operator overloads available are bitwise operations.

std::byte a {0};
std::byte b {0xFF};
int i = std::to_integer<int>(b); // 0xFF
std::byte c = a & b;
int j = std::to_integer<int>(c); // 0

Note that std::byte is simply an enum, and braced initialization of enums become possible thanks to direct-list-initialization of enums.

§§§ Splicing for maps and sets

Moving nodes and merging containers without the overhead of expensive copies, moves, or heap allocations/deallocations.

Moving elements from one map to another:

std::map<int, string> src {{1, "one"}, {2, "two"}, {3, "buckle my shoe"}};
std::map<int, string> dst {{3, "three"}};
dst.insert(src.extract(src.find(1))); // Cheap remove and insert of { 1, "one" } from `src` to `dst`.
dst.insert(src.extract(2)); // Cheap remove and insert of { 2, "two" } from `src` to `dst`.
// dst == { { 1, "one" }, { 2, "two" }, { 3, "three" } };

Inserting an entire set:

std::set<int> src {1, 3, 5};
std::set<int> dst {2, 4, 5};
dst.merge(src);
// src == { 5 }
// dst == { 1, 2, 3, 4, 5 }

Inserting elements which outlive the container:

auto elementFactory() {
  std::set<...> s;
  s.emplace(...);
  return s.extract(s.begin());
}
s2.insert(elementFactory());

Changing the key of a map element:

std::map<int, string> m {{1, "one"}, {2, "two"}, {3, "three"}};
auto e = m.extract(2);
e.key() = 4;
m.insert(std::move(e));
// m == { { 1, "one" }, { 3, "three" }, { 4, "two" } }

§§§ Parallel algorithms

Many of the STL algorithms, such as the copy, find and sort methods, started to support the parallel execution policies: seq, par and par_unseq which translate to “sequentially”, “parallel” and “parallel unsequenced”.

std::vector<int> longVector;
// Find element using parallel execution policy
auto result1 = std::find(std::execution::par, std::begin(longVector), std::end(longVector), 2);
// Sort elements using sequential execution policy
auto result2 = std::sort(std::execution::seq, std::begin(longVector), std::end(longVector));

§§§ std::sample

Samples n elements in the given sequence (without replacement) where every element has an equal chance of being selected.

const std::string ALLOWED_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
std::string guid;
// Sample 5 characters from ALLOWED_CHARS.
std::sample(ALLOWED_CHARS.begin(), ALLOWED_CHARS.end(), std::back_inserter(guid),
  5, std::mt19937{ std::random_device{}() });

std::cout << guid; // e.g. G1fW2

§§§ std::clamp

Clamp given value between a lower and upper bound.

std::clamp(42, -1, 1); // == 1
std::clamp(-42, -1, 1); // == -1
std::clamp(0, -1, 1); // == 0

// `std::clamp` also accepts a custom comparator:
std::clamp(0, -1, 1, std::less<>{}); // == 0

§§§ std::reduce

Fold over a given range of elements. Conceptually similar to std::accumulate, but std::reduce will perform the fold in parallel. Due to the fold being done in parallel, if you specify a binary operation, it is required to be associative and commutative. A given binary operation also should not change any element or invalidate any iterators within the given range.

The default binary operation is std::plus with an initial value of 0.

const std::array<int, 3> a{ 1, 2, 3 };
std::reduce(std::cbegin(a), std::cend(a)); // == 6
// Using a custom binary op:
std::reduce(std::cbegin(a), std::cend(a), 1, std::multiplies<>{}); // == 6

Additionally you can specify transformations for reducers:

std::transform_reduce(std::cbegin(a), std::cend(a), 0, std::plus<>{}, times_ten); // == 60

const std::array<int, 3> b{ 1, 2, 3 };
const auto product_times_ten = [](const auto a, const auto b) { return a * b * 10; };

std::transform_reduce(std::cbegin(a), std::cend(a), std::cbegin(b), 0, std::plus<>{}, product_times_ten); // == 140

§§§ Prefix sum algorithms

Support for prefix sums (both inclusive and exclusive scans) along with transformations.

const std::array<int, 3> a{ 1, 2, 3 };

std::inclusive_scan(std::cbegin(a), std::cend(a),
    std::ostream_iterator<int>{ std::cout, " " }, std::plus<>{}); // 1 3 6

std::exclusive_scan(std::cbegin(a), std::cend(a),
    std::ostream_iterator<int>{ std::cout, " " }, 0, std::plus<>{}); // 0 1 3

const auto times_ten = [](const auto n) { return n * 10; };

std::transform_inclusive_scan(std::cbegin(a), std::cend(a),
    std::ostream_iterator<int>{ std::cout, " " }, std::plus<>{}, times_ten); // 10 30 60

std::transform_exclusive_scan(std::cbegin(a), std::cend(a),
    std::ostream_iterator<int>{ std::cout, " " }, 0, std::plus<>{}, times_ten); // 0 10 30

§§§ GCD and LCM

Greatest common divisor (GCD) and least common multiple (LCM).

const int p = 9;
const int q = 3;
std::gcd(p, q); // == 3
std::lcm(p, q); // == 9

§§§ std::not_fn

Utility function that returns the negation of the result of the given function.

const std::ostream_iterator<int> ostream_it{ std::cout, " " };
const auto is_even = [](const auto n) { return n % 2 == 0; };
std::vector<int> v{ 0, 1, 2, 3, 4 };

// Print all even numbers.
std::copy_if(std::cbegin(v), std::cend(v), ostream_it, is_even); // 0 2 4
// Print all odd (not even) numbers.
std::copy_if(std::cbegin(v), std::cend(v), ostream_it, std::not_fn(is_even)); // 1 3

§§§ String conversion to/from numbers

Convert integrals and floats to a string or vice-versa. Conversions are non-throwing, do not allocate, and are more secure than the equivalents from the C standard library.

Users are responsible for allocating enough storage required for std::to_chars, or the function will fail by setting the error code object in its return value.

These functions allow you to optionally pass a base (defaults to base-10) or a format specifier for floating type input.

std::to_chars returns a (non-const) char pointer which is one-past-the-end of the string that the function wrote to inside the given buffer, and an error code object.
std::from_chars returns a const char pointer which on success is equal to the end pointer passed to the function, and an error code object.

Both error code objects returned from these functions are equal to the default-initialized error code object on success.

Convert the number 123 to a std::string:

const int n = 123;

// Can use any container, string, array, etc.
std::string str;
str.resize(3); // hold enough storage for each digit of `n`

const auto [ ptr, ec ] = std::to_chars(str.data(), str.data() + str.size(), n);

if (ec == std::errc{}) { std::cout << str << std::endl; } // 123
else { /* handle failure */ }

Convert from a std::string with value "123" to an integer:

const std::string str{ "123" };
int n;

const auto [ ptr, ec ] = std::from_chars(str.data(), str.data() + str.size(), n);

if (ec == std::errc{}) { std::cout << n << std::endl; } // 123
else { /* handle failure */ }

§§§ Rounding functions for chrono durations and timepoints

Provides abs, round, ceil, and floor helper functions for std::chrono::duration and std::chrono::time_point.

using seconds = std::chrono::seconds;
std::chrono::milliseconds d{ 5500 };
std::chrono::abs(d); // == 5s
std::chrono::round<seconds>(d); // == 6s
std::chrono::ceil<seconds>(d); // == 6s
std::chrono::floor<seconds>(d); // == 5s

§§ Acknowledgements

cppreference - especially useful for finding examples and documentation of new library features.
C++ Rvalue References Explained - a great introduction I used to understand rvalue references, perfect forwarding, and move semantics.
clang and gcc’s standards support pages. Also included here are the proposals for language/library features that I used to help find a description of, what it’s meant to fix, and some examples.
Compiler explorer
Scott Meyers’ Effective Modern C++ - highly recommended book!
Jason Turner’s C++ Weekly - nice collection of C++-related videos.
What can I do with a moved-from object?
What are some uses of decltype(auto)?
And many more SO posts I’m forgetting…

§§ Author

Anthony Calandra

§§ Content Contributors

See: https://github.com/AnthonyCalandra/modern-cpp-features/graphs/contributors

§§ License

MIT

modern cpp features - C++20

i@shrik3.com (SHRIK3) — Sun, 15 Dec 2024 20:43:04 +0100

§ C++20

§§ Overview

Many of these descriptions and examples are taken from various resources (see Acknowledgements section) and summarized in my own words.

C++20 includes the following new language features:

C++20 includes the following new library features:

§§ C++20 Language Features

§§§ Coroutines

Note: While these examples illustrate how to use coroutines at a basic level, there is lots more going on when the code is compiled. These examples are not meant to be complete coverage of C++20’s coroutines. Since the generator and task classes are not provided by the standard library yet, I used the cppcoro library to compile these examples.

Coroutines are special functions that can have their execution suspended and resumed. To define a coroutine, the co_return, co_await, or co_yield keywords must be present in the function’s body. C++20’s coroutines are stackless; unless optimized out by the compiler, their state is allocated on the heap.

An example of a coroutine is a generator function, which yields (i.e. generates) a value at each invocation:

generator<int> range(int start, int end) {
  while (start < end) {
    co_yield start;
    start++;
  }

  // Implicit co_return at the end of this function:
  // co_return;
}

for (int n : range(0, 10)) {
  std::cout << n << std::endl;
}

The above range generator function generates values starting at start until end (exclusive), with each iteration step yielding the current value stored in start. The generator maintains its state across each invocation of range (in this case, the invocation is for each iteration in the for loop). co_yield takes the given expression, yields (i.e. returns) its value, and suspends the coroutine at that point. Upon resuming, execution continues after the co_yield.

Another example of a coroutine is a task, which is an asynchronous computation that is executed when the task is awaited:

task<void> echo(socket s) {
  for (;;) {
    auto data = co_await s.async_read();
    co_await async_write(s, data);
  }

  // Implicit co_return at the end of this function:
  // co_return;
}

In this example, the co_await keyword is introduced. This keyword takes an expression and suspends execution if the thing you’re awaiting on (in this case, the read or write) is not ready, otherwise you continue execution. (Note that under the hood, co_yield uses co_await.)

Using a task to lazily evaluate a value:

task<int> calculate_meaning_of_life() {
  co_return 42;
}

auto meaning_of_life = calculate_meaning_of_life();
// ...
co_await meaning_of_life; // == 42

§§§ Concepts

Concepts are named compile-time predicates which constrain types. They take the following form:

template < template-parameter-list >
concept concept-name = constraint-expression;

where constraint-expression evaluates to a constexpr Boolean. Constraints should model semantic requirements, such as whether a type is a numeric or hashable. A compiler error results if a given type does not satisfy the concept it’s bound by (i.e. constraint-expression returns false). Because constraints are evaluated at compile-time, they can provide more meaningful error messages and runtime safety.

// `T` is not limited by any constraints.
template <typename T>
concept always_satisfied = true;
// Limit `T` to integrals.
template <typename T>
concept integral = std::is_integral_v<T>;
// Limit `T` to both the `integral` constraint and signedness.
template <typename T>
concept signed_integral = integral<T> && std::is_signed_v<T>;
// Limit `T` to both the `integral` constraint and the negation of the `signed_integral` constraint.
template <typename T>
concept unsigned_integral = integral<T> && !signed_integral<T>;

There are a variety of syntactic forms for enforcing concepts:

// Forms for function parameters:
// `T` is a constrained type template parameter.
template <my_concept T>
void f(T v);

// `T` is a constrained type template parameter.
template <typename T>
  requires my_concept<T>
void f(T v);

// `T` is a constrained type template parameter.
template <typename T>
void f(T v) requires my_concept<T>;

// `v` is a constrained deduced parameter.
void f(my_concept auto v);

// `v` is a constrained non-type template parameter.
template <my_concept auto v>
void g();

// Forms for auto-deduced variables:
// `foo` is a constrained auto-deduced value.
my_concept auto foo = ...;

// Forms for lambdas:
// `T` is a constrained type template parameter.
auto f = []<my_concept T> (T v) {
  // ...
};
// `T` is a constrained type template parameter.
auto f = []<typename T> requires my_concept<T> (T v) {
  // ...
};
// `T` is a constrained type template parameter.
auto f = []<typename T> (T v) requires my_concept<T> {
  // ...
};
// `v` is a constrained deduced parameter.
auto f = [](my_concept auto v) {
  // ...
};
// `v` is a constrained non-type template parameter.
auto g = []<my_concept auto v> () {
  // ...
};

The requires keyword is used either to start a requires clause or a requires expression:

template <typename T>
  requires my_concept<T> // `requires` clause.
void f(T);

template <typename T>
concept callable = requires (T f) { f(); }; // `requires` expression.

template <typename T>
  requires requires (T x) { x + x; } // `requires` clause and expression on same line.
T add(T a, T b) {
  return a + b;
}

Note that the parameter list in a requires expression is optional. Each requirement in a requires expression are one of the following:

Simple requirements - asserts that the given expression is valid.

1
2

template <typename T>
concept callable = requires (T f) { f(); };

Type requirements - denoted by the typename keyword followed by a type name, asserts that the given type name is valid.

struct foo {
  int foo;
};

struct bar {
  using value = int;
  value data;
};

struct baz {
  using value = int;
  value data;
};

// Using SFINAE, enable if `T` is a `baz`.
template <typename T, typename = std::enable_if_t<std::is_same_v<T, baz>>>
struct S {};

template <typename T>
using Ref = T&;

template <typename T>
concept C = requires {
                     // Requirements on type `T`:
  typename T::value; // A) has an inner member named `value`
  typename S<T>;     // B) must have a valid class template specialization for `S`
  typename Ref<T>;   // C) must be a valid alias template substitution
};

template <C T>
void g(T a);

g(foo{}); // ERROR: Fails requirement A.
g(bar{}); // ERROR: Fails requirement B.
g(baz{}); // PASS.

Compound requirements - an expression in braces followed by a trailing return type or type constraint.

template <typename T>
concept C = requires(T x) {
  {*x} -> std::convertible_to<typename T::inner>; // the type of the expression `*x` is convertible to `T::inner`
  {x + 1} -> std::same_as<int>; // the expression `x + 1` satisfies `std::same_as<decltype((x + 1))>`
  {x * 1} -> std::convertible_to<T>; // the type of the expression `x * 1` is convertible to `T`
};

Nested requirements - denoted by the requires keyword, specify additional constraints (such as those on local parameter arguments).

template <typename T>
concept C = requires(T x) {
  requires std::same_as<sizeof(x), size_t>;
};

§§§ Three-way comparison

C++20 introduces the spaceship operator (<=>) as a new way to write comparison functions that reduce boilerplate and help developers define clearer comparison semantics. Defining a three-way comparison operator will autogenerate the other comparison operator functions (i.e. ==, !=, <, etc.).

Three orderings are introduced:

std::strong_ordering: The strong ordering distinguishes between items being equal (identical and interchangeable). Provides less, greater, equivalent, and equal ordering. Examples of comparisons: searching for a specific value in a list, values of integers, case-sensitive strings.
std::weak_ordering: The weak ordering distinguishes between items being equivalent (not identical, but can be interchangeable for the purposes of comparison). Provides less, greater, and equivalent ordering. Examples of comparisons: case-insensitive strings, sorting, comparing some but not all visible members of a class.
std::partial_ordering: The partial ordering follows the same principle of weak ordering but includes the case when an ordering isn’t possible. Provides less, greater, equivalent, and unordered ordering. Examples of comparisons: floating-point values (e.g. NaN).

A defaulted three-way comparison operator does a member-wise comparison:

struct foo {
  int a;
  bool b;
  char c;

  // Compare `a` first, then `b`, then `c` ...
  auto operator<=>(const foo&) const = default;
};

foo f1{0, false, 'a'}, f2{0, true, 'b'};
f1 < f2; // == true
f1 == f2; // == false
f1 >= f2; // == false

You can also define your own comparisons:

struct foo {
  int x;
  bool b;
  char c;
  std::strong_ordering operator<=>(const foo& other) const {
      return x <=> other.x;
  }
};

foo f1{0, false, 'a'}, f2{0, true, 'b'};
f1 < f2; // == false
f1 == f2; // == true
f1 >= f2; // == true

§§§ Designated initializers

C-style designated initializer syntax. Any member fields that are not explicitly listed in the designated initializer list are default-initialized.

struct A {
  int x;
  int y;
  int z = 123;
};

A a {.x = 1, .z = 2}; // a.x == 1, a.y == 0, a.z == 2

§§§ Template syntax for lambdas

Use familiar template syntax in lambda expressions.

1
2
3

auto f = []<typename T>(std::vector<T> v) {
  // ...
};

§§§ Range-based for loop with initializer

This feature simplifies common code patterns, helps keep scopes tight, and offers an elegant solution to a common lifetime problem.

for (auto v = std::vector{1, 2, 3}; auto& e : v) {
  std::cout << e;
}
// prints "123"

§§§ [[likely]] and [[unlikely]] attributes

Provides a hint to the optimizer that the labelled statement has a high probability of being executed.

switch (n) {
case 1:
  // ...
  break;

[[likely]] case 2:  // n == 2 is considered to be arbitrarily more
  // ...            // likely than any other value of n
  break;
}

If one of the likely/unlikely attributes appears after the right parenthesis of an if-statement, it indicates that the branch is likely/unlikely to have its substatement (body) executed.

int random = get_random_number_between_x_and_y(0, 3);
if (random > 0) [[likely]] {
  // body of if statement
  // ...
}

It can also be applied to the substatement (body) of an iteration statement.

while (unlikely_truthy_condition) [[unlikely]] {
  // body of while statement
  // ...
}

§§§ Deprecate implicit capture of this

Implicitly capturing this in a lambda capture using [=] is now deprecated; prefer capturing explicitly using [=, this] or [=, *this].

struct int_value {
  int n = 0;
  auto getter_fn() {
    // BAD:
    // return [=]() { return n; };

    // GOOD:
    return [=, *this]() { return n; };
  }
};

§§§ Class types in non-type template parameters

Classes can now be used in non-type template parameters. Objects passed in as template arguments have the type const T, where T is the type of the object, and has static storage duration.

struct foo {
  foo() = default;
  constexpr foo(int) {}
};

template <foo f = {}>
auto get_foo() {
  return f;
}

get_foo(); // uses implicit constructor
get_foo<foo{123}>();

§§§ constexpr virtual functions

Virtual functions can now be constexpr and evaluated at compile-time. constexpr virtual functions can override non-constexpr virtual functions and vice-versa.

struct X1 {
  virtual int f() const = 0;
};

struct X2: public X1 {
  constexpr virtual int f() const { return 2; }
};

struct X3: public X2 {
  virtual int f() const { return 3; }
};

struct X4: public X3 {
  constexpr virtual int f() const { return 4; }
};

constexpr X4 x4;
x4.f(); // == 4

§§§ explicit(bool)

Conditionally select at compile-time whether a constructor is made explicit or not. explicit(true) is the same as specifying explicit.

struct foo {
  // Specify non-integral types (strings, floats, etc.) require explicit construction.
  template <typename T>
  explicit(!std::is_integral_v<T>) foo(T) {}
};

foo a = 123; // OK
foo b = "123"; // ERROR: explicit constructor is not a candidate (explicit specifier evaluates to true)
foo c {"123"}; // OK

§§§ Immediate functions

Similar to constexpr functions, but functions with a consteval specifier must produce a constant. These are called immediate functions.

consteval int sqr(int n) {
  return n * n;
}

constexpr int r = sqr(100); // OK
int x = 100;
int r2 = sqr(x); // ERROR: the value of 'x' is not usable in a constant expression
                 // OK if `sqr` were a `constexpr` function

§§§ using enum

Bring an enum’s members into scope to improve readability. Before:

enum class rgba_color_channel { red, green, blue, alpha };

std::string_view to_string(rgba_color_channel channel) {
  switch (channel) {
    case rgba_color_channel::red:   return "red";
    case rgba_color_channel::green: return "green";
    case rgba_color_channel::blue:  return "blue";
    case rgba_color_channel::alpha: return "alpha";
  }
}

After:

enum class rgba_color_channel { red, green, blue, alpha };

std::string_view to_string(rgba_color_channel my_channel) {
  switch (my_channel) {
    using enum rgba_color_channel;
    case red:   return "red";
    case green: return "green";
    case blue:  return "blue";
    case alpha: return "alpha";
  }
}

§§§ Lambda capture of parameter pack

Capture parameter packs by value:

template <typename... Args>
auto f(Args&&... args){
    // BY VALUE:
    return [...args = std::forward<Args>(args)] {
        // ...
    };
}

Capture parameter packs by reference:

template <typename... Args>
auto f(Args&&... args){
    // BY REFERENCE:
    return [&...args = std::forward<Args>(args)] {
        // ...
    };
}

§§§ char8_t

Provides a standard type for representing UTF-8 strings.

`1`	`char8_t utf8_str[] = u8"\u0123";`

§§§ constinit

The constinit specifier requires that a variable must be initialized at compile-time.

const char* g() { return "dynamic initialization"; }
constexpr const char* f(bool p) { return p ? "constant initializer" : g(); }

constinit const char* c = f(true); // OK
constinit const char* d = g(false); // ERROR: `g` is not constexpr, so `d` cannot be evaluated at compile-time.

§§§ __VA_OPT__

Helps support variadic macros by evaluating to the given argument if the variadic macro is non-empty.

1
2
3

#define F(...) f(0 __VA_OPT__(,) __VA_ARGS__)
F(a, b, c) // replaced by f(0, a, b, c)
F()        // replaced by f(0)

§§ C++20 Library Features

§§§ Concepts library

Concepts are also provided by the standard library for building more complicated concepts. Some of these include:

Core language concepts:

same_as - specifies two types are the same.
derived_from - specifies that a type is derived from another type.
convertible_to - specifies that a type is implicitly convertible to another type.
common_with - specifies that two types share a common type.
integral - specifies that a type is an integral type.
default_constructible - specifies that an object of a type can be default-constructed.

Comparison concepts:

boolean - specifies that a type can be used in Boolean contexts.
equality_comparable - specifies that operator== is an equivalence relation.

Object concepts:

movable - specifies that an object of a type can be moved and swapped.
copyable - specifies that an object of a type can be copied, moved, and swapped.
semiregular - specifies that an object of a type can be copied, moved, swapped, and default constructed.
regular - specifies that a type is regular, that is, it is both semiregular and equality_comparable.

Callable concepts:

invocable - specifies that a callable type can be invoked with a given set of argument types.
predicate - specifies that a callable type is a Boolean predicate.

§§§ Formatting library

Combine the simplicity of printf with the type-safety of iostream. Uses braces as placeholders, and supports custom formatting similar to printf-style specifiers.

std::format("{1} {0}", "world", "hello"); // == "hello world"

int x = 123;
std::string str = std::format("x: {}", x); // str == "x: 123"

// Format to an output iterator:
for (auto x : {1, 2, 3}) {
  std::format_to(std::ostream_iterator<char>{std::cout, "\n"}, "{}", x);
}

To format custom types:

struct fraction {
  int numerator;
  int denominator;
};

template <>
struct std::formatter<fraction>
{
    constexpr auto parse(std::format_parse_context& ctx) {
      return ctx.begin();
    }

    auto format(const fraction& f, std::format_context& ctx) const {
      return std::format_to(ctx.out(), "{0:d}/{1:d}", f.numerator, f.denominator);
    }
};

fraction f{1, 2};
std::format("{}", f); // == "1/2"

§§§ Synchronized buffered outputstream

Buffers output operations for the wrapped output stream ensuring synchronization (i.e. no interleaving of output).

`1`	`std::osyncstream{std::cout} << "The value of x is:" << x << std::endl;`

§§§ std::span

A span is a view (i.e. non-owning) of a container providing bounds-checked access to a contiguous group of elements. Since views do not own their elements they are cheap to construct and copy – a simplified way to think about views is they are holding references to their data. As opposed to maintaining a pointer/iterator and length field, a span wraps both of those up in a single object.

Spans can be dynamically-sized or fixed-sized (known as their extent). Fixed-sized spans benefit from bounds-checking.

Span doesn’t propogate const so to construct a read-only span use std::span<const T>.

Example: using a dynamically-sized span to print integers from various containers.

void print_ints(std::span<const int> ints) {
    for (const auto n : ints) {
        std::cout << n << std::endl;
    }
}

print_ints(std::vector{ 1, 2, 3 });
print_ints(std::array<int, 5>{ 1, 2, 3, 4, 5 });

int a[10] = { 0 };
print_ints(a);
// etc.

Example: a statically-sized span will fail to compile for containers that don’t match the extent of the span.

void print_three_ints(std::span<const int, 3> ints) {
    for (const auto n : ints) {
        std::cout << n << std::endl;
    }
}

print_three_ints(std::vector{ 1, 2, 3 }); // ERROR
print_three_ints(std::array<int, 5>{ 1, 2, 3, 4, 5 }); // ERROR
int a[10] = { 0 };
print_three_ints(a); // ERROR

std::array<int, 3> b = { 1, 2, 3 };
print_three_ints(b); // OK

// You can construct a span manually if required:
std::vector c{ 1, 2, 3 };
print_three_ints(std::span<const int, 3>{ c.data(), 3 }); // OK: set pointer and length field.
print_three_ints(std::span<const int, 3>{ c.cbegin(), c.cend() }); // OK: use iterator pairs.

§§§ Bit operations

C++20 provides a new <bit> header which provides some bit operations including popcount.

1
2
3

std::popcount(0u); // 0
std::popcount(1u); // 1
std::popcount(0b1111'0000u); // 4

§§§ Math constants

Mathematical constants including PI, Euler’s number, etc. defined in the <numbers> header.

1
2

std::numbers::pi; // 3.14159...
std::numbers::e; // 2.71828...

§§§ std::is_constant_evaluated

Predicate function which is truthy when it is called in a compile-time context.

constexpr bool is_compile_time() {
    return std::is_constant_evaluated();
}

constexpr bool a = is_compile_time(); // true
bool b = is_compile_time(); // false

§§§ std::make_shared supports arrays

1
2
3

auto p = std::make_shared<int[]>(5); // pointer to `int[5]`
// OR
auto p = std::make_shared<int[5]>(); // pointer to `int[5]`

§§§ starts_with and ends_with on strings

Strings (and string views) now have the starts_with and ends_with member functions to check if a string starts or ends with the given string.

1
2
3

std::string str = "foobar";
str.starts_with("foo"); // true
str.ends_with("baz"); // false

§§§ Check if associative container has element

Associative containers such as sets and maps have a contains member function, which can be used instead of the “find and check end of iterator” idiom.

std::map<int, char> map {{1, 'a'}, {2, 'b'}};
map.contains(2); // true
map.contains(123); // false

std::set<int> set {1, 2, 3};
set.contains(2); // true

§§§ std::bit_cast

A safer way to reinterpret an object from one type to another.

1
2

float f = 123.0;
int i = std::bit_cast<int>(f);

§§§ std::midpoint

Calculate the midpoint of two integers safely (without overflow).

`1`	`std::midpoint(1, 3); // == 2`

§§§ std::to_array

Converts the given array/“array-like” object to a std::array.

std::to_array("foo"); // returns `std::array<char, 4>`
std::to_array<int>({1, 2, 3}); // returns `std::array<int, 3>`

int a[] = {1, 2, 3};
std::to_array(a); // returns `std::array<int, 3>`

§§§ std::bind_front

Binds the first N arguments (where N is the number of arguments after the given function to std::bind_front) to a given free function, lambda, or member function.

1
2
3

const auto f = [](int a, int b, int c) { return a + b + c; };
const auto g = std::bind_front(f, 1, 1);
g(1); // == 3

§§§ Uniform container erasure

Provides std::erase and/or std::erase_if for a variety of STL containers such as string, list, vector, map, etc.

For erasing by value use std::erase, or to specify a predicate when to erase elements use std::erase_if. Both functions return the number of erased elements.

1
2
3

std::vector v{0, 1, 0, 2, 0, 3};
std::erase(v, 0); // v == {1, 2, 3}
std::erase_if(v, [](int n) { return n == 0; }); // v == {1, 2, 3}

§§§ Three-way comparison helpers

Helper functions for giving names to comparison results:

1
2
3

std::is_eq(0 <=> 0); // == true
std::is_lteq(0 <=> 1); // == true
std::is_gt(0 <=> 1); // == false

§§§ std::lexicographical_compare_three_way

Lexicographically compares two ranges using three-way comparison and produces a result of the strongest applicable comparison category type.

std::vector a{0, 0, 0}, b{0, 0, 0}, c{1, 1, 1};

auto cmp_ab = std::lexicographical_compare_three_way(
    a.begin(), a.end(), b.begin(), b.end());
std::is_eq(cmp_ab); // == true

auto cmp_ac = std::lexicographical_compare_three_way(
    a.begin(), a.end(), c.begin(), c.end());
std::is_lt(cmp_ac); // == true

§§ Acknowledgements

cppreference - especially useful for finding examples and documentation of new library features.
C++ Rvalue References Explained - a great introduction I used to understand rvalue references, perfect forwarding, and move semantics.
clang and gcc’s standards support pages. Also included here are the proposals for language/library features that I used to help find a description of, what it’s meant to fix, and some examples.
Compiler explorer
Scott Meyers’ Effective Modern C++ - highly recommended book!
Jason Turner’s C++ Weekly - nice collection of C++-related videos.
What can I do with a moved-from object?
What are some uses of decltype(auto)?
And many more SO posts I’m forgetting…

§ COPYING & ATTRIBUTIONS:

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

modern cpp features - overview

i@shrik3.com (SHRIK3) — Sun, 15 Dec 2024 20:43:04 +0100

§ Modern C++ Features (Anthony Calandra), overview C++20/17/14/11

§§ Overview

C++20 includes the following new language features:

C++20 includes the following new library features:

C++17 includes the following new language features:

C++17 includes the following new library features:

C++14 includes the following new language features:

C++14 includes the following new library features:

C++11 includes the following new language features:

C++11 includes the following new library features:

§§ C++20 Language Features

§§§ Coroutines

Note: While these examples illustrate how to use coroutines at a basic level, there is lots more going on when the code is compiled. These examples are not meant to be complete coverage of C++20’s coroutines. Since the generator and task classes are not provided by the standard library yet, I used the cppcoro library to compile these examples.

An example of a coroutine is a generator function, which yields (i.e. generates) a value at each invocation:

generator<int> range(int start, int end) {
  while (start < end) {
    co_yield start;
    start++;
  }

  // Implicit co_return at the end of this function:
  // co_return;
}

for (int n : range(0, 10)) {
  std::cout << n << std::endl;
}

Another example of a coroutine is a task, which is an asynchronous computation that is executed when the task is awaited:

task<void> echo(socket s) {
  for (;;) {
    auto data = co_await s.async_read();
    co_await async_write(s, data);
  }

  // Implicit co_return at the end of this function:
  // co_return;
}

Using a task to lazily evaluate a value:

task<int> calculate_meaning_of_life() {
  co_return 42;
}

auto meaning_of_life = calculate_meaning_of_life();
// ...
co_await meaning_of_life; // == 42

§§§ Concepts

Concepts are named compile-time predicates which constrain types. They take the following form:

template < template-parameter-list >
concept concept-name = constraint-expression;

// `T` is not limited by any constraints.
template <typename T>
concept always_satisfied = true;
// Limit `T` to integrals.
template <typename T>
concept integral = std::is_integral_v<T>;
// Limit `T` to both the `integral` constraint and signedness.
template <typename T>
concept signed_integral = integral<T> && std::is_signed_v<T>;
// Limit `T` to both the `integral` constraint and the negation of the `signed_integral` constraint.
template <typename T>
concept unsigned_integral = integral<T> && !signed_integral<T>;

There are a variety of syntactic forms for enforcing concepts:

// Forms for function parameters:
// `T` is a constrained type template parameter.
template <my_concept T>
void f(T v);

// `T` is a constrained type template parameter.
template <typename T>
  requires my_concept<T>
void f(T v);

// `T` is a constrained type template parameter.
template <typename T>
void f(T v) requires my_concept<T>;

// `v` is a constrained deduced parameter.
void f(my_concept auto v);

// `v` is a constrained non-type template parameter.
template <my_concept auto v>
void g();

// Forms for auto-deduced variables:
// `foo` is a constrained auto-deduced value.
my_concept auto foo = ...;

// Forms for lambdas:
// `T` is a constrained type template parameter.
auto f = []<my_concept T> (T v) {
  // ...
};
// `T` is a constrained type template parameter.
auto f = []<typename T> requires my_concept<T> (T v) {
  // ...
};
// `T` is a constrained type template parameter.
auto f = []<typename T> (T v) requires my_concept<T> {
  // ...
};
// `v` is a constrained deduced parameter.
auto f = [](my_concept auto v) {
  // ...
};
// `v` is a constrained non-type template parameter.
auto g = []<my_concept auto v> () {
  // ...
};

The requires keyword is used either to start a requires clause or a requires expression:

template <typename T>
  requires my_concept<T> // `requires` clause.
void f(T);

template <typename T>
concept callable = requires (T f) { f(); }; // `requires` expression.

template <typename T>
  requires requires (T x) { x + x; } // `requires` clause and expression on same line.
T add(T a, T b) {
  return a + b;
}

Note that the parameter list in a requires expression is optional. Each requirement in a requires expression are one of the following:

Simple requirements - asserts that the given expression is valid.

1
2

template <typename T>
concept callable = requires (T f) { f(); };

Type requirements - denoted by the typename keyword followed by a type name, asserts that the given type name is valid.

struct foo {
  int foo;
};

struct bar {
  using value = int;
  value data;
};

struct baz {
  using value = int;
  value data;
};

// Using SFINAE, enable if `T` is a `baz`.
template <typename T, typename = std::enable_if_t<std::is_same_v<T, baz>>>
struct S {};

template <typename T>
using Ref = T&;

template <typename T>
concept C = requires {
                     // Requirements on type `T`:
  typename T::value; // A) has an inner member named `value`
  typename S<T>;     // B) must have a valid class template specialization for `S`
  typename Ref<T>;   // C) must be a valid alias template substitution
};

template <C T>
void g(T a);

g(foo{}); // ERROR: Fails requirement A.
g(bar{}); // ERROR: Fails requirement B.
g(baz{}); // PASS.

Compound requirements - an expression in braces followed by a trailing return type or type constraint.

template <typename T>
concept C = requires(T x) {
  {*x} -> std::convertible_to<typename T::inner>; // the type of the expression `*x` is convertible to `T::inner`
  {x + 1} -> std::same_as<int>; // the expression `x + 1` satisfies `std::same_as<decltype((x + 1))>`
  {x * 1} -> std::convertible_to<T>; // the type of the expression `x * 1` is convertible to `T`
};

Nested requirements - denoted by the requires keyword, specify additional constraints (such as those on local parameter arguments).

template <typename T>
concept C = requires(T x) {
  requires std::same_as<sizeof(x), size_t>;
};

§§§ Three-way comparison

Three orderings are introduced:

std::strong_ordering: The strong ordering distinguishes between items being equal (identical and interchangeable). Provides less, greater, equivalent, and equal ordering. Examples of comparisons: searching for a specific value in a list, values of integers, case-sensitive strings.
std::weak_ordering: The weak ordering distinguishes between items being equivalent (not identical, but can be interchangeable for the purposes of comparison). Provides less, greater, and equivalent ordering. Examples of comparisons: case-insensitive strings, sorting, comparing some but not all visible members of a class.
std::partial_ordering: The partial ordering follows the same principle of weak ordering but includes the case when an ordering isn’t possible. Provides less, greater, equivalent, and unordered ordering. Examples of comparisons: floating-point values (e.g. NaN).

A defaulted three-way comparison operator does a member-wise comparison:

struct foo {
  int a;
  bool b;
  char c;

  // Compare `a` first, then `b`, then `c` ...
  auto operator<=>(const foo&) const = default;
};

foo f1{0, false, 'a'}, f2{0, true, 'b'};
f1 < f2; // == true
f1 == f2; // == false
f1 >= f2; // == false

You can also define your own comparisons:

struct foo {
  int x;
  bool b;
  char c;
  std::strong_ordering operator<=>(const foo& other) const {
      return x <=> other.x;
  }
};

foo f1{0, false, 'a'}, f2{0, true, 'b'};
f1 < f2; // == false
f1 == f2; // == true
f1 >= f2; // == true

§§§ Designated initializers

C-style designated initializer syntax. Any member fields that are not explicitly listed in the designated initializer list are default-initialized.

struct A {
  int x;
  int y;
  int z = 123;
};

A a {.x = 1, .z = 2}; // a.x == 1, a.y == 0, a.z == 2

§§§ Template syntax for lambdas

Use familiar template syntax in lambda expressions.

1
2
3

auto f = []<typename T>(std::vector<T> v) {
  // ...
};

§§§ Range-based for loop with initializer

This feature simplifies common code patterns, helps keep scopes tight, and offers an elegant solution to a common lifetime problem.

for (auto v = std::vector{1, 2, 3}; auto& e : v) {
  std::cout << e;
}
// prints "123"

§§§ `[[likely]]` and `[[unlikely]]` attributes

Provides a hint to the optimizer that the labelled statement has a high probability of being executed.

switch (n) {
case 1:
  // ...
  break;

[[likely]] case 2:  // n == 2 is considered to be arbitrarily more
  // ...            // likely than any other value of n
  break;
}

If one of the likely/unlikely attributes appears after the right parenthesis of an if-statement, it indicates that the branch is likely/unlikely to have its substatement (body) executed.

int random = get_random_number_between_x_and_y(0, 3);
if (random > 0) [[likely]] {
  // body of if statement
  // ...
}

It can also be applied to the substatement (body) of an iteration statement.

while (unlikely_truthy_condition) [[unlikely]] {
  // body of while statement
  // ...
}

§§§ Deprecate implicit capture of this

Implicitly capturing this in a lambda capture using [=] is now deprecated; prefer capturing explicitly using [=, this] or [=, *this].

struct int_value {
  int n = 0;
  auto getter_fn() {
    // BAD:
    // return [=]() { return n; };

    // GOOD:
    return [=, *this]() { return n; };
  }
};

§§§ Class types in non-type template parameters

Classes can now be used in non-type template parameters. Objects passed in as template arguments have the type const T, where T is the type of the object, and has static storage duration.

struct foo {
  foo() = default;
  constexpr foo(int) {}
};

template <foo f = {}>
auto get_foo() {
  return f;
}

get_foo(); // uses implicit constructor
get_foo<foo{123}>();

§§§ constexpr virtual functions

Virtual functions can now be constexpr and evaluated at compile-time. constexpr virtual functions can override non-constexpr virtual functions and vice-versa.

struct X1 {
  virtual int f() const = 0;
};

struct X2: public X1 {
  constexpr virtual int f() const { return 2; }
};

struct X3: public X2 {
  virtual int f() const { return 3; }
};

struct X4: public X3 {
  constexpr virtual int f() const { return 4; }
};

constexpr X4 x4;
x4.f(); // == 4

§§§ explicit(bool)

Conditionally select at compile-time whether a constructor is made explicit or not. explicit(true) is the same as specifying explicit.

struct foo {
  // Specify non-integral types (strings, floats, etc.) require explicit construction.
  template <typename T>
  explicit(!std::is_integral_v<T>) foo(T) {}
};

foo a = 123; // OK
foo b = "123"; // ERROR: explicit constructor is not a candidate (explicit specifier evaluates to true)
foo c {"123"}; // OK

§§§ Immediate functions

Similar to constexpr functions, but functions with a consteval specifier must produce a constant. These are called immediate functions.

consteval int sqr(int n) {
  return n * n;
}

constexpr int r = sqr(100); // OK
int x = 100;
int r2 = sqr(x); // ERROR: the value of 'x' is not usable in a constant expression
                 // OK if `sqr` were a `constexpr` function

§§§ using enum

Bring an enum’s members into scope to improve readability. Before:

enum class rgba_color_channel { red, green, blue, alpha };

std::string_view to_string(rgba_color_channel channel) {
  switch (channel) {
    case rgba_color_channel::red:   return "red";
    case rgba_color_channel::green: return "green";
    case rgba_color_channel::blue:  return "blue";
    case rgba_color_channel::alpha: return "alpha";
  }
}

After:

enum class rgba_color_channel { red, green, blue, alpha };

std::string_view to_string(rgba_color_channel my_channel) {
  switch (my_channel) {
    using enum rgba_color_channel;
    case red:   return "red";
    case green: return "green";
    case blue:  return "blue";
    case alpha: return "alpha";
  }
}

§§§ Lambda capture of parameter pack

Capture parameter packs by value:

template <typename... Args>
auto f(Args&&... args){
    // BY VALUE:
    return [...args = std::forward<Args>(args)] {
        // ...
    };
}

Capture parameter packs by reference:

template <typename... Args>
auto f(Args&&... args){
    // BY REFERENCE:
    return [&...args = std::forward<Args>(args)] {
        // ...
    };
}

§§§ char8_t

Provides a standard type for representing UTF-8 strings.

`1`	`char8_t utf8_str[] = u8"\u0123";`

§§§ constinit

The constinit specifier requires that a variable must be initialized at compile-time.

const char* g() { return "dynamic initialization"; }
constexpr const char* f(bool p) { return p ? "constant initializer" : g(); }

constinit const char* c = f(true); // OK
constinit const char* d = g(false); // ERROR: `g` is not constexpr, so `d` cannot be evaluated at compile-time.

§§§ __VA_OPT__

Helps support variadic macros by evaluating to the given argument if the variadic macro is non-empty.

1
2
3

#define F(...) f(0 __VA_OPT__(,) __VA_ARGS__)
F(a, b, c) // replaced by f(0, a, b, c)
F()        // replaced by f(0)

§§ C++20 Library Features

§§§ Concepts library

Concepts are also provided by the standard library for building more complicated concepts. Some of these include:

Core language concepts:

same_as - specifies two types are the same.
derived_from - specifies that a type is derived from another type.
convertible_to - specifies that a type is implicitly convertible to another type.
common_with - specifies that two types share a common type.
integral - specifies that a type is an integral type.
default_constructible - specifies that an object of a type can be default-constructed.

Comparison concepts:

boolean - specifies that a type can be used in Boolean contexts.
equality_comparable - specifies that operator== is an equivalence relation.

Object concepts:

movable - specifies that an object of a type can be moved and swapped.
copyable - specifies that an object of a type can be copied, moved, and swapped.
semiregular - specifies that an object of a type can be copied, moved, swapped, and default constructed.
regular - specifies that a type is regular, that is, it is both semiregular and equality_comparable.

Callable concepts:

invocable - specifies that a callable type can be invoked with a given set of argument types.
predicate - specifies that a callable type is a Boolean predicate.

§§§ Formatting library

Combine the simplicity of printf with the type-safety of iostream. Uses braces as placeholders, and supports custom formatting similar to printf-style specifiers.

std::format("{1} {0}", "world", "hello"); // == "hello world"

int x = 123;
std::string str = std::format("x: {}", x); // str == "x: 123"

// Format to an output iterator:
for (auto x : {1, 2, 3}) {
  std::format_to(std::ostream_iterator<char>{std::cout, "\n"}, "{}", x);
}

To format custom types:

struct fraction {
  int numerator;
  int denominator;
};

template <>
struct std::formatter<fraction>
{
    constexpr auto parse(std::format_parse_context& ctx) {
      return ctx.begin();
    }

    auto format(const fraction& f, std::format_context& ctx) const {
      return std::format_to(ctx.out(), "{0:d}/{1:d}", f.numerator, f.denominator);
    }
};

fraction f{1, 2};
std::format("{}", f); // == "1/2"

§§§ Synchronized buffered outputstream

Buffers output operations for the wrapped output stream ensuring synchronization (i.e. no interleaving of output).

`1`	`std::osyncstream{std::cout} << "The value of x is:" << x << std::endl;`

§§§ std::span

Spans can be dynamically-sized or fixed-sized (known as their extent). Fixed-sized spans benefit from bounds-checking.

Span doesn’t propogate const so to construct a read-only span use std::span<const T>.

Example: using a dynamically-sized span to print integers from various containers.

void print_ints(std::span<const int> ints) {
    for (const auto n : ints) {
        std::cout << n << std::endl;
    }
}

print_ints(std::vector{ 1, 2, 3 });
print_ints(std::array<int, 5>{ 1, 2, 3, 4, 5 });

int a[10] = { 0 };
print_ints(a);
// etc.

Example: a statically-sized span will fail to compile for containers that don’t match the extent of the span.

void print_three_ints(std::span<const int, 3> ints) {
    for (const auto n : ints) {
        std::cout << n << std::endl;
    }
}

print_three_ints(std::vector{ 1, 2, 3 }); // ERROR
print_three_ints(std::array<int, 5>{ 1, 2, 3, 4, 5 }); // ERROR
int a[10] = { 0 };
print_three_ints(a); // ERROR

std::array<int, 3> b = { 1, 2, 3 };
print_three_ints(b); // OK

// You can construct a span manually if required:
std::vector c{ 1, 2, 3 };
print_three_ints(std::span<const int, 3>{ c.data(), 3 }); // OK: set pointer and length field.
print_three_ints(std::span<const int, 3>{ c.cbegin(), c.cend() }); // OK: use iterator pairs.

§§§ Bit operations

C++20 provides a new <bit> header which provides some bit operations including popcount.

1
2
3

std::popcount(0u); // 0
std::popcount(1u); // 1
std::popcount(0b1111'0000u); // 4

§§§ Math constants

Mathematical constants including PI, Euler’s number, etc. defined in the <numbers> header.

1
2

std::numbers::pi; // 3.14159...
std::numbers::e; // 2.71828...

§§§ std::is_constant_evaluated

Predicate function which is truthy when it is called in a compile-time context.

constexpr bool is_compile_time() {
    return std::is_constant_evaluated();
}

constexpr bool a = is_compile_time(); // true
bool b = is_compile_time(); // false

§§§ std::make_shared supports arrays

1
2
3

auto p = std::make_shared<int[]>(5); // pointer to `int[5]`
// OR
auto p = std::make_shared<int[5]>(); // pointer to `int[5]`

§§§ starts_with and ends_with on strings

Strings (and string views) now have the starts_with and ends_with member functions to check if a string starts or ends with the given string.

1
2
3

std::string str = "foobar";
str.starts_with("foo"); // true
str.ends_with("baz"); // false

§§§ Check if associative container has element

Associative containers such as sets and maps have a contains member function, which can be used instead of the “find and check end of iterator” idiom.

std::map<int, char> map {{1, 'a'}, {2, 'b'}};
map.contains(2); // true
map.contains(123); // false

std::set<int> set {1, 2, 3};
set.contains(2); // true

§§§ std::bit_cast

A safer way to reinterpret an object from one type to another.

1
2

float f = 123.0;
int i = std::bit_cast<int>(f);

§§§ std::midpoint

Calculate the midpoint of two integers safely (without overflow).

`1`	`std::midpoint(1, 3); // == 2`

§§§ std::to_array

Converts the given array/“array-like” object to a std::array.

std::to_array("foo"); // returns `std::array<char, 4>`
std::to_array<int>({1, 2, 3}); // returns `std::array<int, 3>`

int a[] = {1, 2, 3};
std::to_array(a); // returns `std::array<int, 3>`

§§§ std::bind_front

Binds the first N arguments (where N is the number of arguments after the given function to std::bind_front) to a given free function, lambda, or member function.

1
2
3

const auto f = [](int a, int b, int c) { return a + b + c; };
const auto g = std::bind_front(f, 1, 1);
g(1); // == 3

§§§ Uniform container erasure

Provides std::erase and/or std::erase_if for a variety of STL containers such as string, list, vector, map, etc.

For erasing by value use std::erase, or to specify a predicate when to erase elements use std::erase_if. Both functions return the number of erased elements.

1
2
3

std::vector v{0, 1, 0, 2, 0, 3};
std::erase(v, 0); // v == {1, 2, 3}
std::erase_if(v, [](int n) { return n == 0; }); // v == {1, 2, 3}

§§§ Three-way comparison helpers

Helper functions for giving names to comparison results:

1
2
3

std::is_eq(0 <=> 0); // == true
std::is_lteq(0 <=> 1); // == true
std::is_gt(0 <=> 1); // == false

§§§ std::lexicographical_compare_three_way

Lexicographically compares two ranges using three-way comparison and produces a result of the strongest applicable comparison category type.

std::vector a{0, 0, 0}, b{0, 0, 0}, c{1, 1, 1};

auto cmp_ab = std::lexicographical_compare_three_way(
    a.begin(), a.end(), b.begin(), b.end());
std::is_eq(cmp_ab); // == true

auto cmp_ac = std::lexicographical_compare_three_way(
    a.begin(), a.end(), c.begin(), c.end());
std::is_lt(cmp_ac); // == true

§§ C++17 Language Features

§§§ Template argument deduction for class templates

Automatic template argument deduction much like how it’s done for functions, but now including class constructors.

template <typename T = float>
struct MyContainer {
  T val;
  MyContainer() : val{} {}
  MyContainer(T val) : val{val} {}
  // ...
};
MyContainer c1 {1}; // OK MyContainer<int>
MyContainer c2; // OK MyContainer<float>

§§§ Declaring non-type template parameters with auto

Following the deduction rules of auto, while respecting the non-type template parameter list of allowable types[*], template arguments can be deduced from the types of its arguments:

template <auto... seq>
struct my_integer_sequence {
  // Implementation here ...
};

// Explicitly pass type `int` as template argument.
auto seq = std::integer_sequence<int, 0, 1, 2>();
// Type is deduced to be `int`.
auto seq2 = my_integer_sequence<0, 1, 2>();

* - For example, you cannot use a double as a template parameter type, which also makes this an invalid deduction using auto.

§§§ Folding expressions

A fold expression performs a fold of a template parameter pack over a binary operator.

An expression of the form (... op e) or (e op ...), where op is a fold-operator and e is an unexpanded parameter pack, are called unary folds.
An expression of the form (e1 op ... op e2), where op are fold-operators, is called a binary fold. Either e1 or e2 is an unexpanded parameter pack, but not both.

template <typename... Args>
bool logicalAnd(Args... args) {
    // Binary folding.
    return (true && ... && args);
}
bool b = true;
bool& b2 = b;
logicalAnd(b, b2, true); // == true

template <typename... Args>
auto sum(Args... args) {
    // Unary folding.
    return (... + args);
}
sum(1.0, 2.0f, 3); // == 6.0

§§§ New rules for auto deduction from braced-init-list

Changes to auto deduction when used with the uniform initialization syntax. Previously, auto x {3}; deduces a std::initializer_list<int>, which now deduces to int.

auto x1 {1, 2, 3}; // error: not a single element
auto x2 = {1, 2, 3}; // x2 is std::initializer_list<int>
auto x3 {3}; // x3 is int
auto x4 {3.0}; // x4 is double

§§§ constexpr lambda

Compile-time lambdas using constexpr.

1
2

auto identity = [](int n) constexpr { return n; };
static_assert(identity(123) == 123);

constexpr auto add = [](int x, int y) {
  auto L = [=] { return x; };
  auto R = [=] { return y; };
  return [=] { return L() + R(); };
};

static_assert(add(1, 2)() == 3);

constexpr int addOne(int n) {
  return [n] { return n + 1; }();
}

static_assert(addOne(1) == 2);

§§§ Lambda capture `this` by value

struct MyObj {
  int value {123};
  auto getValueCopy() {
    return [*this] { return value; };
  }
  auto getValueRef() {
    return [this] { return value; };
  }
};
MyObj mo;
auto valueCopy = mo.getValueCopy();
auto valueRef = mo.getValueRef();
mo.value = 321;
valueCopy(); // 123
valueRef(); // 321

§§§ Inline variables

The inline specifier can be applied to variables as well as to functions. A variable declared inline has the same semantics as a function declared inline.

// Disassembly example using compiler explorer.
struct S { int x; };
inline S x1 = S{321}; // mov esi, dword ptr [x1]
                      // x1: .long 321

S x2 = S{123};        // mov eax, dword ptr [.L_ZZ4mainE2x2]
                      // mov dword ptr [rbp - 8], eax
                      // .L_ZZ4mainE2x2: .long 123

It can also be used to declare and define a static member variable, such that it does not need to be initialized in the source file.

struct S {
  S() : id{count++} {}
  ~S() { count--; }
  int id;
  static inline int count{0}; // declare and initialize count to 0 within the class
};

§§§ Nested namespaces

Using the namespace resolution operator to create nested namespace definitions.

namespace A {
  namespace B {
    namespace C {
      int i;
    }
  }
}

The code above can be written like this:

1
2
3

namespace A::B::C {
  int i;
}

§§§ Structured bindings

using Coordinate = std::pair<int, int>;
Coordinate origin() {
  return Coordinate{0, 0};
}

const auto [ x, y ] = origin();
x; // == 0
y; // == 0

std::unordered_map<std::string, int> mapping {
  {"a", 1},
  {"b", 2},
  {"c", 3}
};

// Destructure by reference.
for (const auto& [key, value] : mapping) {
  // Do something with key and value
}

§§§ Selection statements with initializer

New versions of the if and switch statements which simplify common code patterns and help users keep scopes tight.

{
  std::lock_guard<std::mutex> lk(mx);
  if (v.empty()) v.push_back(val);
}
// vs.
if (std::lock_guard<std::mutex> lk(mx); v.empty()) {
  v.push_back(val);
}

Foo gadget(args);
switch (auto s = gadget.status()) {
  case OK: gadget.zip(); break;
  case Bad: throw BadFoo(s.message());
}
// vs.
switch (Foo gadget(args); auto s = gadget.status()) {
  case OK: gadget.zip(); break;
  case Bad: throw BadFoo(s.message());
}

§§§ constexpr if

Write code that is instantiated depending on a compile-time condition.

template <typename T>
constexpr bool isIntegral() {
  if constexpr (std::is_integral<T>::value) {
    return true;
  } else {
    return false;
  }
}
static_assert(isIntegral<int>() == true);
static_assert(isIntegral<char>() == true);
static_assert(isIntegral<double>() == false);
struct S {};
static_assert(isIntegral<S>() == false);

§§§ UTF-8 character literals

A character literal that begins with u8 is a character literal of type char. The value of a UTF-8 character literal is equal to its ISO 10646 code point value.

`1`	`char x = u8'x';`

§§§ Direct list initialization of enums

Enums can now be initialized using braced syntax.

enum byte : unsigned char {};
byte b {0}; // OK
byte c {-1}; // ERROR
byte d = byte{1}; // OK
byte e = byte{256}; // ERROR

§§§ `[[fallthrough]]`, `[[nodiscard]]`, `[[maybe_unused]]` attributes

C++17 introduces three new attributes: [[fallthrough]], [[nodiscard]] and [[maybe_unused]].

[[fallthrough]] indicates to the compiler that falling through in a switch statement is intended behavior. This attribute may only be used in a switch statement, and must be placed before the next case/default label.

switch (n) {
  case 1: 
    // ...
    [[fallthrough]];
  case 2:
    // ...
    break;
  case 3:
    // ...
    [[fallthrough]];
  default:
    // ...
}

[[nodiscard]] issues a warning when either a function or class has this attribute and its return value is discarded.

[[nodiscard]] bool do_something() {
  return is_success; // true for success, false for failure
}

do_something(); // warning: ignoring return value of 'bool do_something()',
                // declared with attribute 'nodiscard'

// Only issues a warning when `error_info` is returned by value.
struct [[nodiscard]] error_info {
  // ...
};

error_info do_something() {
  error_info ei;
  // ...
  return ei;
}

do_something(); // warning: ignoring returned value of type 'error_info',
                // declared with attribute 'nodiscard'

[[maybe_unused]] indicates to the compiler that a variable or parameter might be unused and is intended.

void my_callback(std::string msg, [[maybe_unused]] bool error) {
  // Don't care if `msg` is an error message, just log it.
  log(msg);
}

§§§ __has_include

__has_include (operand) operator may be used in #if and #elif expressions to check whether a header or source file (operand) is available for inclusion or not.

One use case of this would be using two libraries that work the same way, using the backup/experimental one if the preferred one is not found on the system.

#ifdef __has_include
#  if __has_include(<optional>)
#    include <optional>
#    define have_optional 1
#  elif __has_include(<experimental/optional>)
#    include <experimental/optional>
#    define have_optional 1
#    define experimental_optional
#  else
#    define have_optional 0
#  endif
#endif

#ifdef __has_include
#  if __has_include(<OpenGL/gl.h>)
#    include <OpenGL/gl.h>
#    include <OpenGL/glu.h>
#  elif __has_include(<GL/gl.h>)
#    include <GL/gl.h>
#    include <GL/glu.h>
#  else
#    error No suitable OpenGL headers found.
# endif
#endif

§§§ Class template argument deduction

Class template argument deduction (CTAD) allows the compiler to deduce template arguments from constructor arguments.

std::vector v{ 1, 2, 3 }; // deduces std::vector<int>

std::mutex mtx;
auto lck = std::lock_guard{ mtx }; // deduces to std::lock_guard<std::mutex>

auto p = new std::pair{ 1.0, 2.0 }; // deduces to std::pair<double, double>*

For user-defined types, deduction guides can be used to guide the compiler how to deduce template arguments if applicable:

template <typename T>
struct container {
  container(T t) {}

  template <typename Iter>
  container(Iter beg, Iter end);
};

// deduction guide
template <typename Iter>
container(Iter b, Iter e) -> container<typename std::iterator_traits<Iter>::value_type>;

container a{ 7 }; // OK: deduces container<int>

std::vector<double> v{ 1.0, 2.0, 3.0 };
auto b = container{ v.begin(), v.end() }; // OK: deduces container<double>

container c{ 5, 6 }; // ERROR: std::iterator_traits<int>::value_type is not a type

§§ C++17 Library Features

§§§ std::variant

std::variant<int, double> v{ 12 };
std::get<int>(v); // == 12
std::get<0>(v); // == 12
v = 12.0;
std::get<double>(v); // == 12.0
std::get<1>(v); // == 12.0

§§§ std::optional

The class template std::optional manages an optional contained value, i.e. a value that may or may not be present. A common use case for optional is the return value of a function that may fail.

std::optional<std::string> create(bool b) {
  if (b) {
    return "Godzilla";
  } else {
    return {};
  }
}

create(false).value_or("empty"); // == "empty"
create(true).value(); // == "Godzilla"
// optional-returning factory functions are usable as conditions of while and if
if (auto str = create(true)) {
  // ...
}

§§§ std::any

A type-safe container for single values of any type.

std::any x {5};
x.has_value() // == true
std::any_cast<int>(x) // == 5
std::any_cast<int&>(x) = 10;
std::any_cast<int>(x) // == 10

§§§ std::string_view

A non-owning reference to a string. Useful for providing an abstraction on top of strings (e.g. for parsing).

// Regular strings.
std::string_view cppstr {"foo"};
// Wide strings.
std::wstring_view wcstr_v {L"baz"};
// Character arrays.
char array[3] = {'b', 'a', 'r'};
std::string_view array_v(array, std::size(array));

std::string str {"   trim me"};
std::string_view v {str};
v.remove_prefix(std::min(v.find_first_not_of(" "), v.size()));
str; //  == "   trim me"
v; // == "trim me"

§§§ std::invoke

Invoke a Callable object with parameters. Examples of callable objects are std::function or lambdas; objects that can be called similarly to a regular function.

template <typename Callable>
class Proxy {
  Callable c_;

public:
  Proxy(Callable c) : c_{ std::move(c) } {}

  template <typename... Args>
  decltype(auto) operator()(Args&&... args) {
    // ...
    return std::invoke(c_, std::forward<Args>(args)...);
  }
};

const auto add = [](int x, int y) { return x + y; };
Proxy p{ add };
p(1, 2); // == 3

§§§ std::apply

Invoke a Callable object with a tuple of arguments.

auto add = [](int x, int y) {
  return x + y;
};
std::apply(add, std::make_tuple(1, 2)); // == 3

§§§ std::filesystem

The new std::filesystem library provides a standard way to manipulate files, directories, and paths in a filesystem.

Here, a big file is copied to a temporary path if there is available space:

const auto bigFilePath {"bigFileToCopy"};
if (std::filesystem::exists(bigFilePath)) {
  const auto bigFileSize {std::filesystem::file_size(bigFilePath)};
  std::filesystem::path tmpPath {"/tmp"};
  if (std::filesystem::space(tmpPath).available > bigFileSize) {
    std::filesystem::create_directory(tmpPath.append("example"));
    std::filesystem::copy_file(bigFilePath, tmpPath.append("newFile"));
  }
}

§§§ std::byte

std::byte a {0};
std::byte b {0xFF};
int i = std::to_integer<int>(b); // 0xFF
std::byte c = a & b;
int j = std::to_integer<int>(c); // 0

Note that std::byte is simply an enum, and braced initialization of enums become possible thanks to direct-list-initialization of enums.

§§§ Splicing for maps and sets

Moving nodes and merging containers without the overhead of expensive copies, moves, or heap allocations/deallocations.

Moving elements from one map to another:

std::map<int, string> src {{1, "one"}, {2, "two"}, {3, "buckle my shoe"}};
std::map<int, string> dst {{3, "three"}};
dst.insert(src.extract(src.find(1))); // Cheap remove and insert of { 1, "one" } from `src` to `dst`.
dst.insert(src.extract(2)); // Cheap remove and insert of { 2, "two" } from `src` to `dst`.
// dst == { { 1, "one" }, { 2, "two" }, { 3, "three" } };

Inserting an entire set:

std::set<int> src {1, 3, 5};
std::set<int> dst {2, 4, 5};
dst.merge(src);
// src == { 5 }
// dst == { 1, 2, 3, 4, 5 }

Inserting elements which outlive the container:

auto elementFactory() {
  std::set<...> s;
  s.emplace(...);
  return s.extract(s.begin());
}
s2.insert(elementFactory());

Changing the key of a map element:

std::map<int, string> m {{1, "one"}, {2, "two"}, {3, "three"}};
auto e = m.extract(2);
e.key() = 4;
m.insert(std::move(e));
// m == { { 1, "one" }, { 3, "three" }, { 4, "two" } }

§§§ Parallel algorithms

std::vector<int> longVector;
// Find element using parallel execution policy
auto result1 = std::find(std::execution::par, std::begin(longVector), std::end(longVector), 2);
// Sort elements using sequential execution policy
auto result2 = std::sort(std::execution::seq, std::begin(longVector), std::end(longVector));

§§§ std::sample

Samples n elements in the given sequence (without replacement) where every element has an equal chance of being selected.

const std::string ALLOWED_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
std::string guid;
// Sample 5 characters from ALLOWED_CHARS.
std::sample(ALLOWED_CHARS.begin(), ALLOWED_CHARS.end(), std::back_inserter(guid),
  5, std::mt19937{ std::random_device{}() });

std::cout << guid; // e.g. G1fW2

§§§ std::clamp

Clamp given value between a lower and upper bound.

std::clamp(42, -1, 1); // == 1
std::clamp(-42, -1, 1); // == -1
std::clamp(0, -1, 1); // == 0

// `std::clamp` also accepts a custom comparator:
std::clamp(0, -1, 1, std::less<>{}); // == 0

§§§ std::reduce

The default binary operation is std::plus with an initial value of 0.

const std::array<int, 3> a{ 1, 2, 3 };
std::reduce(std::cbegin(a), std::cend(a)); // == 6
// Using a custom binary op:
std::reduce(std::cbegin(a), std::cend(a), 1, std::multiplies<>{}); // == 6

Additionally you can specify transformations for reducers:

std::transform_reduce(std::cbegin(a), std::cend(a), 0, std::plus<>{}, times_ten); // == 60

const std::array<int, 3> b{ 1, 2, 3 };
const auto product_times_ten = [](const auto a, const auto b) { return a * b * 10; };

std::transform_reduce(std::cbegin(a), std::cend(a), std::cbegin(b), 0, std::plus<>{}, product_times_ten); // == 140

§§§ Prefix sum algorithms

Support for prefix sums (both inclusive and exclusive scans) along with transformations.

const std::array<int, 3> a{ 1, 2, 3 };

std::inclusive_scan(std::cbegin(a), std::cend(a),
    std::ostream_iterator<int>{ std::cout, " " }, std::plus<>{}); // 1 3 6

std::exclusive_scan(std::cbegin(a), std::cend(a),
    std::ostream_iterator<int>{ std::cout, " " }, 0, std::plus<>{}); // 0 1 3

const auto times_ten = [](const auto n) { return n * 10; };

std::transform_inclusive_scan(std::cbegin(a), std::cend(a),
    std::ostream_iterator<int>{ std::cout, " " }, std::plus<>{}, times_ten); // 10 30 60

std::transform_exclusive_scan(std::cbegin(a), std::cend(a),
    std::ostream_iterator<int>{ std::cout, " " }, 0, std::plus<>{}, times_ten); // 0 10 30

§§§ GCD and LCM

Greatest common divisor (GCD) and least common multiple (LCM).

const int p = 9;
const int q = 3;
std::gcd(p, q); // == 3
std::lcm(p, q); // == 9

§§§ std::not_fn

Utility function that returns the negation of the result of the given function.

const std::ostream_iterator<int> ostream_it{ std::cout, " " };
const auto is_even = [](const auto n) { return n % 2 == 0; };
std::vector<int> v{ 0, 1, 2, 3, 4 };

// Print all even numbers.
std::copy_if(std::cbegin(v), std::cend(v), ostream_it, is_even); // 0 2 4
// Print all odd (not even) numbers.
std::copy_if(std::cbegin(v), std::cend(v), ostream_it, std::not_fn(is_even)); // 1 3

§§§ String conversion to/from numbers

Convert integrals and floats to a string or vice-versa. Conversions are non-throwing, do not allocate, and are more secure than the equivalents from the C standard library.

Users are responsible for allocating enough storage required for std::to_chars, or the function will fail by setting the error code object in its return value.

These functions allow you to optionally pass a base (defaults to base-10) or a format specifier for floating type input.

std::to_chars returns a (non-const) char pointer which is one-past-the-end of the string that the function wrote to inside the given buffer, and an error code object.
std::from_chars returns a const char pointer which on success is equal to the end pointer passed to the function, and an error code object.

Both error code objects returned from these functions are equal to the default-initialized error code object on success.

Convert the number 123 to a std::string:

const int n = 123;

// Can use any container, string, array, etc.
std::string str;
str.resize(3); // hold enough storage for each digit of `n`

const auto [ ptr, ec ] = std::to_chars(str.data(), str.data() + str.size(), n);

if (ec == std::errc{}) { std::cout << str << std::endl; } // 123
else { /* handle failure */ }

Convert from a std::string with value "123" to an integer:

const std::string str{ "123" };
int n;

const auto [ ptr, ec ] = std::from_chars(str.data(), str.data() + str.size(), n);

if (ec == std::errc{}) { std::cout << n << std::endl; } // 123
else { /* handle failure */ }

§§§ Rounding functions for chrono durations and timepoints

Provides abs, round, ceil, and floor helper functions for std::chrono::duration and std::chrono::time_point.

using seconds = std::chrono::seconds;
std::chrono::milliseconds d{ 5500 };
std::chrono::abs(d); // == 5s
std::chrono::round<seconds>(d); // == 6s
std::chrono::ceil<seconds>(d); // == 6s
std::chrono::floor<seconds>(d); // == 5s

§§ C++14 Language Features

§§§ Binary literals

Binary literals provide a convenient way to represent a base-2 number. It is possible to separate digits with '.

1
2

0b110 // == 6
0b1111'1111 // == 255

§§§ Generic lambda expressions

C++14 now allows the auto type-specifier in the parameter list, enabling polymorphic lambdas.

1
2
3

auto identity = [](auto x) { return x; };
int three = identity(3); // == 3
std::string foo = identity("foo"); // == "foo"

§§§ Lambda capture initializers

int factory(int i) { return i * 10; }
auto f = [x = factory(2)] { return x; }; // returns 20

auto generator = [x = 0] () mutable {
  // this would not compile without 'mutable' as we are modifying x on each call
  return x++;
};
auto a = generator(); // == 0
auto b = generator(); // == 1
auto c = generator(); // == 2

auto p = std::make_unique<int>(1);

auto task1 = [=] { *p = 5; }; // ERROR: std::unique_ptr cannot be copied
// vs.
auto task2 = [p = std::move(p)] { *p = 5; }; // OK: p is move-constructed into the closure object
// the original p is empty after task2 is created

Using this reference-captures can have different names than the referenced variable.

auto x = 1;
auto f = [&r = x, x = x * 10] {
  ++r;
  return r + x;
};
f(); // sets x to 2 and returns 12

§§§ Return type deduction

// Deduce return type as `int`.
auto f(int i) {
 return i;
}

template <typename T>
auto& f(T& t) {
  return t;
}

// Returns a reference to a deduced type.
auto g = [](auto& x) -> auto& { return f(x); };
int y = 123;
int& z = g(y); // reference to `y`

§§§ decltype(auto)

The decltype(auto) type-specifier also deduces a type like auto does. However, it deduces return types while keeping their references and cv-qualifiers, while auto will not.

const int x = 0;
auto x1 = x; // int
decltype(auto) x2 = x; // const int
int y = 0;
int& y1 = y;
auto y2 = y1; // int
decltype(auto) y3 = y1; // int&
int&& z = 0;
auto z1 = std::move(z); // int
decltype(auto) z2 = std::move(z); // int&&

// Note: Especially useful for generic code!

// Return type is `int`.
auto f(const int& i) {
 return i;
}

// Return type is `const int&`.
decltype(auto) g(const int& i) {
 return i;
}

int x = 123;
static_assert(std::is_same<const int&, decltype(f(x))>::value == 0);
static_assert(std::is_same<int, decltype(f(x))>::value == 1);
static_assert(std::is_same<const int&, decltype(g(x))>::value == 1);

§§§ Relaxing constraints on constexpr functions

constexpr int factorial(int n) {
  if (n <= 1) {
    return 1;
  } else {
    return n * factorial(n - 1);
  }
}
factorial(5); // == 120

§§§ Variable templates

C++14 allows variables to be templated:

template<class T>
constexpr T pi = T(3.1415926535897932385);
template<class T>
constexpr T e  = T(2.7182818284590452353);

§§§ `[[deprecated]]` attribute

[[deprecated]]
void old_method();
[[deprecated("Use new_method instead")]]
void legacy_method();

§§ C++14 Library Features

§§§ User-defined literals for standard library types

using namespace std::chrono_literals;
auto day = 24h;
day.count(); // == 24
std::chrono::duration_cast<std::chrono::minutes>(day).count(); // == 1440

§§§ Compile-time integer sequences

The class template std::integer_sequence represents a compile-time sequence of integers. There are a few helpers built on top:

std::make_integer_sequence<T, N> - creates a sequence of 0, ..., N - 1 with type T.
std::index_sequence_for<T...> - converts a template parameter pack into an integer sequence.

Convert an array into a tuple:

template<typename Array, std::size_t... I>
decltype(auto) a2t_impl(const Array& a, std::integer_sequence<std::size_t, I...>) {
  return std::make_tuple(a[I]...);
}

template<typename T, std::size_t N, typename Indices = std::make_index_sequence<N>>
decltype(auto) a2t(const std::array<T, N>& a) {
  return a2t_impl(a, Indices());
}

§§§ std::make_unique

std::make_unique is the recommended way to create instances of std::unique_ptrs due to the following reasons:

Avoid having to use the new operator.
Prevents code repetition when specifying the underlying type the pointer shall hold.
Most importantly, it provides exception-safety. Suppose we were calling a function foo like so:

`1`	`foo(std::unique_ptr<T>{new T{}}, function_that_throws(), std::unique_ptr<T>{new T{}});`

`1`	`foo(std::make_unique<T>(), function_that_throws(), std::make_unique<T>());`

See the section on smart pointers (C++11) for more information on std::unique_ptr and std::shared_ptr.

§§ C++11 Language Features

§§§ Move semantics

Moving an object means to transfer ownership of some resource it manages to another object.

See the sections on: rvalue references, special member functions for move semantics, std::move, std::forward, forwarding references.

§§§ Rvalue references

Type deduction with lvalues and rvalues:

int x = 0; // `x` is an lvalue of type `int`
int& xl = x; // `xl` is an lvalue of type `int&`
int&& xr = x; // compiler error -- `x` is an lvalue
int&& xr2 = 0; // `xr2` is an lvalue of type `int&&` -- binds to the rvalue temporary, `0`

void f(int& x) {}
void f(int&& x) {}

f(x);  // calls f(int&)
f(xl); // calls f(int&)
f(3);  // calls f(int&&)
f(std::move(x)); // calls f(int&&)

f(xr2);           // calls f(int&)
f(std::move(xr2)); // calls f(int&& x)

§§§ Forwarding references

Forwarding references allow a reference to bind to either an lvalue or rvalue depending on the type. Forwarding references follow the rules of reference collapsing:

T& & becomes T&
T& && becomes T&
T&& & becomes T&
T&& && becomes T&&

auto type deduction with lvalues and rvalues:

1
2
3

int x = 0; // `x` is an lvalue of type `int`
auto&& al = x; // `al` is an lvalue of type `int&` -- binds to the lvalue, `x`
auto&& ar = 0; // `ar` is an lvalue of type `int&&` -- binds to the rvalue temporary, `0`

Template type parameter deduction with lvalues and rvalues:

// Since C++14 or later:
void f(auto&& t) {
  // ...
}

// Since C++11 or later:
template <typename T>
void f(T&& t) {
  // ...
}

int x = 0;
f(0); // T is int, deduces as f(int &&) => f(int&&)
f(x); // T is int&, deduces as f(int& &&) => f(int&)

int& y = x;
f(y); // T is int&, deduces as f(int& &&) => f(int&)

int&& z = 0; // NOTE: `z` is an lvalue with type `int&&`.
f(z); // T is int&, deduces as f(int& &&) => f(int&)
f(std::move(z)); // T is int, deduces as f(int &&) => f(int&&)

§§§ Variadic templates

template <typename... T>
struct arity {
  constexpr static int value = sizeof...(T);
};
static_assert(arity<>::value == 0);
static_assert(arity<char, short, int>::value == 3);

An interesting use for this is creating an initializer list from a parameter pack in order to iterate over variadic function arguments.

template <typename First, typename... Args>
auto sum(const First first, const Args... args) -> decltype(first) {
  const auto values = {first, args...};
  return std::accumulate(values.begin(), values.end(), First{0});
}

sum(1, 2, 3, 4, 5); // 15
sum(1, 2, 3);       // 6
sum(1.5, 2.0, 3.7); // 7.2

§§§ Initializer lists

int sum(const std::initializer_list<int>& list) {
  int total = 0;
  for (auto& e : list) {
    total += e;
  }

  return total;
}

auto list = {1, 2, 3};
sum(list); // == 6
sum({1, 2, 3}); // == 6
sum({}); // == 0

§§§ Static assertions

Assertions that are evaluated at compile-time.

1
2
3

constexpr int x = 0;
constexpr int y = 1;
static_assert(x == y, "x != y");

§§§ auto

auto-typed variables are deduced by the compiler according to the type of their initializer.

auto a = 3.14; // double
auto b = 1; // int
auto& c = b; // int&
auto d = { 0 }; // std::initializer_list<int>
auto&& e = 1; // int&&
auto&& f = b; // int&
auto g = new auto(123); // int*
const auto h = 1; // const int
auto i = 1, j = 2, k = 3; // int, int, int
auto l = 1, m = true, n = 1.61; // error -- `l` deduced to be int, `m` is bool
auto o; // error -- `o` requires initializer

Extremely useful for readability, especially for complicated types:

std::vector<int> v = ...;
std::vector<int>::const_iterator cit = v.cbegin();
// vs.
auto cit = v.cbegin();

Functions can also deduce the return type using auto. In C++11, a return type must be specified either explicitly, or using decltype like so:

template <typename X, typename Y>
auto add(X x, Y y) -> decltype(x + y) {
  return x + y;
}
add(1, 2); // == 3
add(1, 2.0); // == 3.0
add(1.5, 1.5); // == 3.0

§§§ Lambda expressions

[] - captures nothing.
[=] - capture local objects (local variables, parameters) in scope by value.
[&] - capture local objects (local variables, parameters) in scope by reference.
[this] - capture this by reference.
[a, &b] - capture objects a by value, b by reference.

int x = 1;

auto getX = [=] { return x; };
getX(); // == 1

auto addX = [=](int y) { return x + y; };
addX(1); // == 2

auto getXRef = [&]() -> int& { return x; };
getXRef(); // int& to `x`

int x = 1;

auto f1 = [&x] { x = 2; }; // OK: x is a reference and modifies the original

auto f2 = [x] { x = 2; }; // ERROR: the lambda can only perform const-operations on the captured value
// vs.
auto f3 = [x]() mutable { x = 2; }; // OK: the lambda can perform any operations on the captured value

§§§ decltype

decltype is an operator which returns the declared type of an expression passed to it. cv-qualifiers and references are maintained if they are part of the expression. Examples of decltype:

int a = 1; // `a` is declared as type `int`
decltype(a) b = a; // `decltype(a)` is `int`
const int& c = a; // `c` is declared as type `const int&`
decltype(c) d = a; // `decltype(c)` is `const int&`
decltype(123) e = 123; // `decltype(123)` is `int`
int&& f = 1; // `f` is declared as type `int&&`
decltype(f) g = 1; // `decltype(f) is `int&&`
decltype((a)) h = g; // `decltype((a))` is int&

template <typename X, typename Y>
auto add(X x, Y y) -> decltype(x + y) {
  return x + y;
}
add(1, 2.0); // `decltype(x + y)` => `decltype(3.0)` => `double`

§§§ Type aliases

Semantically similar to using a typedef however, type aliases with using are easier to read and are compatible with templates.

template <typename T>
using Vec = std::vector<T>;
Vec<int> v; // std::vector<int>

using String = std::string;
String s {"foo"};

§§§ nullptr

void foo(int);
void foo(char*);
foo(NULL); // error -- ambiguous
foo(nullptr); // calls foo(char*)

§§§ Strongly-typed enums

Type-safe enums that solve a variety of problems with C-style enums including: implicit conversions, inability to specify the underlying type, scope pollution.

// Specifying underlying type as `unsigned int`
enum class Color : unsigned int { Red = 0xff0000, Green = 0xff00, Blue = 0xff };
// `Red`/`Green` in `Alert` don't conflict with `Color`
enum class Alert : bool { Red, Green };
Color c = Color::Red;

§§§ Attributes

Attributes provide a universal syntax over __attribute__(...), __declspec, etc.

// `noreturn` attribute indicates `f` doesn't return.
[[ noreturn ]] void f() {
  throw "error";
}

§§§ constexpr

constexpr int square(int x) {
  return x * x;
}

int square2(int x) {
  return x * x;
}

int a = square(2);  // mov DWORD PTR [rbp-4], 4

int b = square2(2); // mov edi, 2
                    // call square2(int)
                    // mov DWORD PTR [rbp-8], eax

constexpr values are those that the compiler can evaluate, but are not guaranteed to, at compile-time:

1
2

const int x = 123;
constexpr const int& y = x; // error -- constexpr variable `y` must be initialized by a constant expression

Constant expressions with classes:

struct Complex {
  constexpr Complex(double r, double i) : re{r}, im{i} { }
  constexpr double real() { return re; }
  constexpr double imag() { return im; }

private:
  double re;
  double im;
};

constexpr Complex I(0, 1);

§§§ Delegating constructors

Constructors can now call other constructors in the same class using an initializer list.

struct Foo {
  int foo;
  Foo(int foo) : foo{foo} {}
  Foo() : Foo(0) {}
};

Foo foo;
foo.foo; // == 0

§§§ User-defined literals

Converting Celsius to Fahrenheit:

// `unsigned long long` parameter required for integer literal.
long long operator "" _celsius(unsigned long long tempCelsius) {
  return std::llround(tempCelsius * 1.8 + 32);
}
24_celsius; // == 75

String to integer conversion:

// `const char*` and `std::size_t` required as parameters.
int operator "" _int(const char* str, std::size_t) {
  return std::stoi(str);
}

"123"_int; // == 123, with type `int`

§§§ Explicit virtual overrides

Specifies that a virtual function overrides another virtual function. If the virtual function does not override a parent’s virtual function, throws a compiler error.

struct A {
  virtual void foo();
  void bar();
};

struct B : A {
  void foo() override; // correct -- B::foo overrides A::foo
  void bar() override; // error -- A::bar is not virtual
  void baz() override; // error -- B::baz does not override A::baz
};

§§§ Final specifier

Specifies that a virtual function cannot be overridden in a derived class or that a class cannot be inherited from.

struct A {
  virtual void foo();
};

struct B : A {
  virtual void foo() final;
};

struct C : B {
  virtual void foo(); // error -- declaration of 'foo' overrides a 'final' function
};

Class cannot be inherited from.

1
2

struct A final {};
struct B : A {}; // error -- base 'A' is marked 'final'

§§§ Default functions

A more elegant, efficient way to provide a default implementation of a function, such as a constructor.

struct A {
  A() = default;
  A(int x) : x{x} {}
  int x {1};
};
A a; // a.x == 1
A a2 {123}; // a.x == 123

With inheritance:

struct B {
  B() : x{1} {}
  int x;
};

struct C : B {
  // Calls B::B
  C() = default;
};

C c; // c.x == 1

§§§ Deleted functions

A more elegant, efficient way to provide a deleted implementation of a function. Useful for preventing copies on objects.

class A {
  int x;

public:
  A(int x) : x{x} {};
  A(const A&) = delete;
  A& operator=(const A&) = delete;
};

A x {123};
A y = x; // error -- call to deleted copy constructor
y = x; // error -- operator= deleted

§§§ Range-based for loops

Syntactic sugar for iterating over a container’s elements.

1
2
3

std::array<int, 5> a {1, 2, 3, 4, 5};
for (int& x : a) x *= 2;
// a == { 2, 4, 6, 8, 10 }

Note the difference when using int as opposed to int&:

1
2
3

std::array<int, 5> a {1, 2, 3, 4, 5};
for (int x : a) x *= 2;
// a == { 1, 2, 3, 4, 5 }

§§§ Special member functions for move semantics

struct A {
  std::string s;
  A() : s{"test"} {}
  A(const A& o) : s{o.s} {}
  A(A&& o) : s{std::move(o.s)} {}
  A& operator=(A&& o) {
   s = std::move(o.s);
   return *this;
  }
};

A f(A a) {
  return a;
}

A a1 = f(A{}); // move-constructed from rvalue temporary
A a2 = std::move(a1); // move-constructed using std::move
A a3 = A{};
a2 = std::move(a3); // move-assignment using std::move
a1 = f(A{}); // move-assignment from rvalue temporary

§§§ Converting constructors

Converting constructors will convert values of braced list syntax into constructor arguments.

struct A {
  A(int) {}
  A(int, int) {}
  A(int, int, int) {}
};

A a {0, 0}; // calls A::A(int, int)
A b(0, 0); // calls A::A(int, int)
A c = {0, 0}; // calls A::A(int, int)
A d {0, 0, 0}; // calls A::A(int, int, int)

Note that the braced list syntax does not allow narrowing:

struct A {
  A(int) {}
};

A a(1.1); // OK
A b {1.1}; // Error narrowing conversion from double to int

Note that if a constructor accepts a std::initializer_list, it will be called instead:

struct A {
  A(int) {}
  A(int, int) {}
  A(int, int, int) {}
  A(std::initializer_list<int>) {}
};

A a {0, 0}; // calls A::A(std::initializer_list<int>)
A b(0, 0); // calls A::A(int, int)
A c = {0, 0}; // calls A::A(std::initializer_list<int>)
A d {0, 0, 0}; // calls A::A(std::initializer_list<int>)

§§§ Explicit conversion functions

Conversion functions can now be made explicit using the explicit specifier.

struct A {
  operator bool() const { return true; }
};

struct B {
  explicit operator bool() const { return true; }
};

A a;
if (a); // OK calls A::operator bool()
bool ba = a; // OK copy-initialization selects A::operator bool()

B b;
if (b); // OK calls B::operator bool()
bool bb = b; // error copy-initialization does not consider B::operator bool()

§§§ Inline namespaces

namespace Program {
  namespace Version1 {
    int getVersion() { return 1; }
    bool isFirstVersion() { return true; }
  }
  inline namespace Version2 {
    int getVersion() { return 2; }
  }
}

int version {Program::getVersion()};              // Uses getVersion() from Version2
int oldVersion {Program::Version1::getVersion()}; // Uses getVersion() from Version1
bool firstVersion {Program::isFirstVersion()};    // Does not compile when Version2 is added

§§§ Non-static data member initializers

Allows non-static data members to be initialized where they are declared, potentially cleaning up constructors of default initializations.

// Default initialization prior to C++11
class Human {
    Human() : age{0} {}
  private:
    unsigned age;
};
// Default initialization on C++11
class Human {
  private:
    unsigned age {0};
};

§§§ Right angle brackets

C++11 is now able to infer when a series of right angle brackets is used as an operator or as a closing statement of typedef, without having to add whitespace.

1
2

typedef std::map<int, std::map <int, std::map <int, int> > > cpp98LongTypedef;
typedef std::map<int, std::map <int, std::map <int, int>>>   cpp11LongTypedef;

§§§ Ref-qualified member functions

Member functions can now be qualified depending on whether *this is an lvalue or rvalue reference.

struct Bar {
  // ...
};

struct Foo {
  Bar& getBar() & { return bar; }
  const Bar& getBar() const& { return bar; }
  Bar&& getBar() && { return std::move(bar); }
  const Bar&& getBar() const&& { return std::move(bar); }
private:
  Bar bar;
};

Foo foo{};
Bar bar = foo.getBar(); // calls `Bar& getBar() &`

const Foo foo2{};
Bar bar2 = foo2.getBar(); // calls `Bar& Foo::getBar() const&`

Foo{}.getBar(); // calls `Bar&& Foo::getBar() &&`
std::move(foo).getBar(); // calls `Bar&& Foo::getBar() &&`
std::move(foo2).getBar(); // calls `const Bar&& Foo::getBar() const&`

§§§ Trailing return types

C++11 allows functions and lambdas an alternative syntax for specifying their return types.

int f() {
  return 123;
}
// vs.
auto f() -> int {
  return 123;
}

1
2
3

auto g = []() -> int {
  return 123;
};

This feature is especially useful when certain return types cannot be resolved:

// NOTE: This does not compile!
template <typename T, typename U>
decltype(a + b) add(T a, U b) {
    return a + b;
}

// Trailing return types allows this:
template <typename T, typename U>
auto add(T a, U b) -> decltype(a + b) {
    return a + b;
}

In C++14, decltype(auto) (C++14) can be used instead.

§§§ Noexcept specifier

The noexcept specifier specifies whether a function could throw exceptions. It is an improved version of throw().

void func1() noexcept;        // does not throw
void func2() noexcept(true);  // does not throw
void func3() throw();         // does not throw

void func4() noexcept(false); // may throw

extern void f();  // potentially-throwing
void g() noexcept {
    f();          // valid, even if f throws
    throw 42;     // valid, effectively a call to std::terminate
}

§§§ char32_t and char16_t

Provides standard types for representing UTF-8 strings.

1
2

char32_t utf8_str[] = U"\u0123";
char16_t utf8_str[] = u"\u0123";

§§§ Raw string literals

A raw string literal is declared using the following syntax:

R"delimiter(raw_characters)delimiter"

where:

delimiter is an optional sequence of characters made of any source character except parentheses, backslashes and spaces.
raw_characters is any raw character sequence; must not contain the closing sequence ")delimiter".

Example:

// msg1 and msg2 are equivalent.
const char* msg1 = "\nHello,\n\tworld!\n";
const char* msg2 = R"(
Hello,
	world!
)";

§§ C++11 Library Features

§§§ std::move

A definition of std::move (performing a move is nothing more than casting to an rvalue reference):

template <typename T>
typename remove_reference<T>::type&& move(T&& arg) {
  return static_cast<typename remove_reference<T>::type&&>(arg);
}

Transferring std::unique_ptrs:

std::unique_ptr<int> p1 {new int{0}};  // in practice, use std::make_unique
std::unique_ptr<int> p2 = p1; // error -- cannot copy unique pointers
std::unique_ptr<int> p3 = std::move(p1); // move `p1` into `p3`
                                         // now unsafe to dereference object held by `p1`

§§§ std::forward

Returns the arguments passed to it while maintaining their value category and cv-qualifiers. Useful for generic code and factories. Used in conjunction with forwarding references.

A definition of std::forward:

template <typename T>
T&& forward(typename remove_reference<T>::type& arg) {
  return static_cast<T&&>(arg);
}

An example of a function wrapper which just forwards other A objects to a new A object’s copy or move constructor:

struct A {
  A() = default;
  A(const A& o) { std::cout << "copied" << std::endl; }
  A(A&& o) { std::cout << "moved" << std::endl; }
};

template <typename T>
A wrapper(T&& arg) {
  return A{std::forward<T>(arg)};
}

wrapper(A{}); // moved
A a;
wrapper(a); // copied
wrapper(std::move(a)); // moved

§§§ std::thread

void foo(bool clause) { /* do something... */ }

std::vector<std::thread> threadsVector;
threadsVector.emplace_back([]() {
  // Lambda function that will be invoked
});
threadsVector.emplace_back(foo, true);  // thread will run foo(true)
for (auto& thread : threadsVector) {
  thread.join(); // Wait for threads to finish
}

§§§ std::to_string

Converts a numeric argument to a std::string.

1
2

std::to_string(1.2); // == "1.2"
std::to_string(123); // == "123"

§§§ Type traits

Type traits defines a compile-time template-based interface to query or modify the properties of types.

1
2
3

static_assert(std::is_integral<int>::value);
static_assert(std::is_same<int, int>::value);
static_assert(std::is_same<std::conditional<true, int, double>::type, int>::value);

§§§ Smart pointers

C++11 introduces new smart pointers: std::unique_ptr, std::shared_ptr, std::weak_ptr. std::auto_ptr now becomes deprecated and then eventually removed in C++17.

std::unique_ptr<Foo> p1 { new Foo{} };  // `p1` owns `Foo`
if (p1) {
  p1->bar();
}

{
  std::unique_ptr<Foo> p2 {std::move(p1)};  // Now `p2` owns `Foo`
  f(*p2);

  p1 = std::move(p2);  // Ownership returns to `p1` -- `p2` gets destroyed
}

if (p1) {
  p1->bar();
}
// `Foo` instance is destroyed when `p1` goes out of scope

void foo(std::shared_ptr<T> t) {
  // Do something with `t`...
}

void bar(std::shared_ptr<T> t) {
  // Do something with `t`...
}

void baz(std::shared_ptr<T> t) {
  // Do something with `t`...
}

std::shared_ptr<T> p1 {new T{}};
// Perhaps these take place in another threads?
foo(p1);
bar(p1);
baz(p1);

§§§ std::chrono

The chrono library contains a set of utility functions and types that deal with durations, clocks, and time points. One use case of this library is benchmarking code:

std::chrono::time_point<std::chrono::steady_clock> start, end;
start = std::chrono::steady_clock::now();
// Some computations...
end = std::chrono::steady_clock::now();

std::chrono::duration<double> elapsed_seconds = end - start;
double t = elapsed_seconds.count(); // t number of seconds, represented as a `double`

§§§ Tuples

Tuples are a fixed-size collection of heterogeneous values. Access the elements of a std::tuple by unpacking using std::tie, or using std::get.

// `playerProfile` has type `std::tuple<int, const char*, const char*>`.
auto playerProfile = std::make_tuple(51, "Frans Nielsen", "NYI");
std::get<0>(playerProfile); // 51
std::get<1>(playerProfile); // "Frans Nielsen"
std::get<2>(playerProfile); // "NYI"

§§§ std::tie

// With tuples...
std::string playerName;
std::tie(std::ignore, playerName, std::ignore) = std::make_tuple(91, "John Tavares", "NYI");

// With pairs...
std::string yes, no;
std::tie(yes, no) = std::make_pair("yes", "no");

§§§ std::array

std::array is a container built on top of a C-style array. Supports common container operations such as sorting.

1
2
3

std::array<int, 3> a = {2, 1, 3};
std::sort(a.begin(), a.end()); // a == { 1, 2, 3 }
for (int& x : a) x *= 2; // a == { 2, 4, 6 }

§§§ Unordered containers

unordered_set
unordered_multiset
unordered_map
unordered_multimap

§§§ std::make_shared

std::make_shared is the recommended way to create instances of std::shared_ptrs due to the following reasons:

Avoid having to use the new operator.
Prevents code repetition when specifying the underlying type the pointer shall hold.
It provides exception-safety. Suppose we were calling a function foo like so:

`1`	`foo(std::shared_ptr<T>{new T{}}, function_that_throws(), std::shared_ptr<T>{new T{}});`

`1`	`foo(std::make_shared<T>(), function_that_throws(), std::make_shared<T>());`

Prevents having to do two allocations. When calling std::shared_ptr{ new T{} }, we have to allocate memory for T, then in the shared pointer we have to allocate memory for the control block within the pointer.

See the section on smart pointers for more information on std::unique_ptr and std::shared_ptr.

§§§ std::ref

// create a container to store reference of objects.
auto val = 99;
auto _ref = std::ref(val);
_ref++;
auto _cref = std::cref(val);
//_cref++; does not compile
std::vector<std::reference_wrapper<int>>vec; // vector<int&>vec does not compile
vec.push_back(_ref); // vec.push_back(&i) does not compile
cout << val << endl; // prints 100
cout << vec[0] << endl; // prints 100
cout << _cref; // prints 100

§§§ Memory model

See the sections on: std::thread

§§§ std::async

std::async runs the given function either asynchronously or lazily-evaluated, then returns a std::future which holds the result of that function call.

The first parameter is the policy which can be:

std::launch::async | std::launch::deferred It is up to the implementation whether to perform asynchronous execution or lazy evaluation.
std::launch::async Run the callable object on a new thread.
std::launch::deferred Perform lazy evaluation on the current thread.

int foo() {
  /* Do something here, then return the result. */
  return 1000;
}

auto handle = std::async(std::launch::async, foo);  // create an async task
auto result = handle.get();  // wait for the result

§§§ std::begin/end

template <typename T>
int CountTwos(const T& container) {
  return std::count_if(std::begin(container), std::end(container), [](int item) {
    return item == 2;
  });
}

std::vector<int> vec = {2, 2, 43, 435, 4543, 534};
int arr[8] = {2, 43, 45, 435, 32, 32, 32, 32};
auto a = CountTwos(vec); // 2
auto b = CountTwos(arr);  // 1

§§ Acknowledgements

cppreference - especially useful for finding examples and documentation of new library features.
C++ Rvalue References Explained - a great introduction I used to understand rvalue references, perfect forwarding, and move semantics.
clang and gcc’s standards support pages. Also included here are the proposals for language/library features that I used to help find a description of, what it’s meant to fix, and some examples.
Compiler explorer
Scott Meyers’ Effective Modern C++ - highly recommended series of books!
Jason Turner’s C++ Weekly - nice collection of C++-related videos.
What can I do with a moved-from object?
What are some uses of decltype(auto)?

§ COPYING & ATTRIBUTIONS:

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Volatile/
│ checklist for learning programming language	25-Feb-2026
│ quotes	24-Jan-2025
│ request for comment	12-Nov-2024
│ footguns	04-Nov-2024
│ random pieces	26-Oct-2024
│ Wiedergabe - Musik Review	29-Aug-2024
│ Take	19-Aug-2024
│ 我该怎么用中文说....	05-Aug-2024
│ 避免部分互联网内容 (ongoing)	22-Jul-2024
│ rants and shitposting	27-Jun-2024
│ [R18G] [CONTENT WARNING] code gore	10-May-2024
│ fiction, illusion and dream	30-Apr-2024
│ Travels bloody travels	07-Apr-2024
│ System Maintenance Log	05-Apr-2024
│ Pinned: stuffs that I keep googling again and again and again...	30-Nov-2023
│ DON'T FORGET, DON'T FORGIVE	21-Oct-2022
│ Bookmarks	07-Jun-2020
│ TIL: quick facts I learned	01-Jan-0001
paper reading/
│ The Nucleus of a Multiprogramming System	21-Oct-2025
Post/
│ Nix(OS) notes/
│ │ nix 01 - Nix subsystem for arch	03-Aug-2025
│ box drawing characters	18-May-2025
│ archived/
│ │ hugo weird list	20-Jan-2025
│ │ Blog visitor counter	01-May-2022
│ │ 如何用区块链合约做一个赌博应用？	01-Jan-1970
│ │ 微博模拟登陆研究	01-Jan-1970
│ btw, I use arch/
│ │ archlinux setup + LUKS + LVM	22-Aug-2025
│ │ selfhosted AUR repo	04-Dec-2024
│ │ Installing Archlinux on removable media	22-Jun-2020
│ │ archlinux setup no bullshit	04-Jun-2020
│ │ [DEPRECATED] 一些archlinux的配置文件	11-Jul-2019
│ │ [DEPRECATED] archlinux使用贴士	01-Jan-1970
│ fun/
│ │ STOP USING(DOING) NERD FONTS	26-Feb-2024
│ │ Human as runtime	05-Oct-2023
│ │ western numbering is unfit for computer science, embrace the oriental	30-Sep-2023
│ hugo/
│ │ hugo recursive listings	21-Jan-2025
│ │ hugo license helpers	08-Oct-2024
│ │ pure fucking plaintext	08-Oct-2024
│ │ No bullshit hugo blog	21-Apr-2024
│ │ A Static Art Gallery with Hugo	29-Mar-2024
│ │ Hello html	24-Mar-2024
│ │ Comment system on a static site without javascript???	06-Oct-2023
│ │ Add katex support to Hugo	29-May-2020
│ humachine/
│ │ FUCK YOUR MBTI BULLSHIT	10-Mar-2024
│ │ The media exploits ADHD (WIP // DRAFT)	15-Jan-2024
│ │ reflections on generative AIs	12-Jan-2024
│ │ Der Untergang des Wissens...	31-Jan-2023
│ prog/
│ │ C syntax is bad for regex	03-Jan-2024
│ │ Git or not git ... lessons learned (WIP)	13-Dec-2023
│ │ Binary Hacks - on inspecting a binary (ELF)	16-Oct-2023
│ │ End the holy war between space and tab indentation...	13-Oct-2023
│ │ Cursed C - snippets from Expert C Programming	04-Oct-2023
│ │ A simple kernel module	12-Jul-2020
│ pseudo/
│ │ Colors - It's more complicated than you think	07-May-2022
│ │ 语言的数量	13-Feb-2021
│ │ Das Wortproblem und Berechnungsmodell	16-Nov-2020
│ │ Word problem(Decision Problem), Complexity and computing models	16-Nov-2020
│ │ P,NP,NP-Hard and NP-Complete	16-Nov-2020
│ │ Stellenwertsystemen, Konvertierungen und Genauigkeit	11-Nov-2020
│ │ How RSA works	03-Jun-2020
│ scripts/
│ │ no bullshit code explorer	28-Jan-2025
│ │ my blog deploy script	19-Jan-2025
│ │ Text to speech in (neo)vim...	12-Oct-2023
│ │ Tomato clock!	07-Oct-2023
│ │ trivial spotify script..	01-Feb-2023
│ │ switch vim buffers	26-Jan-2021
│ │ NASA's astronomy picture of the day	29-May-2020
│ sys/
│ │ Memory Jargons	22-Jul-2025
│ │ how fast are things in Linux (WIP)	04-Dec-2024
│ │ SysV ABI (AMD64)	23-Sep-2024
│ │ // DRAFT // The archtecture terminimology madness	25-Feb-2024
│ │ ELF, symbol table, and dynamic linking (WIP)	16-Feb-2024
│ │ How much Page Tables / PTEs are needed for xyz amount of memory?	29-Jan-2024
│ │ Chinese translations of computer terminologies (WIP)	06-Dec-2023
│ │ (WIP) Enclave Schizophrenia - What's TEE identity in Attestation?	03-May-2023
│ │ [WIP] send to stdin per PID	01-Feb-2023
│ │ OS notes	03-Feb-2021
│ │ osc/
│ │ │ CGA显示	25-Apr-2022
│ userland/
│ │ enabling sysrq	03-Feb-2025
│ │ replace GnuPG with age and signify	29-Jan-2025
│ │ ANSI escape code and OSC (terminal)	29-Jan-2025
│ │ shells, bashrc and fish	25-Jan-2025
│ │ Tile Split Tile Split Tile (rants)	14-Oct-2023
│ │ set up SSH tunnel for machines behind NAT	03-Oct-2023
│ │ Debian x VirtualBox Image checklist	04-Apr-2023
│ │ The cursed way to use a neovim-IDE on the CLOUD	12-Jan-2023
│ │ postgresql upgrade	24-Apr-2022
│ │ Make screenshare work in wayland	25-Nov-2021
│ │ xmonad Experience + i3-like config	20-May-2021
│ │ nvidia-xrun solution on hybrid graphic + tearing free	18-Nov-2020
│ │ Raspberry Pi as printing/file server	22-Jul-2020
│ │ bundle multiple ssh operations in scripts	24-May-2020
│ │ 有关UUID	12-Jul-2019
│ vim/
│ │ vim thoughts and rants	27-Jan-2025
│ │ time to write neovim plugins	23-Jan-2025
│ │ previously on neovim	21-Nov-2024
│ │ schnitzel.nvim : my neovim config	27-Nov-2023
│ │ Friendship ended with Packer	22-Sep-2023
│ │ Notes on (neo)vim	18-Nov-2022
│ │ vim tricks	17-Nov-2022
│ │ A (neo)vim IDE setup for C/C++, that just works	18-Apr-2022
│ │ Vim tab&buffer confusion	30-May-2020
│ www/
│ │ Fediverse: Small Instance Pipedream	24-Jan-2025
│ │ totally paranoid WWW guidelines	17-Jan-2025
│ │ The Fucking Web	06-May-2024
│ │ openring + webring, build a suckless web	07-Dec-2023
│ │ JS or no JS, that's a problem - towards a ZERO JS blog	07-Oct-2023
│ │ now on fediverse(pleroma)!	21-Jun-2021
│ │ Build your own search Engine	11-Jun-2020
Root/
│ test	28-Jul-2025
│ site map	10-Feb-2025
│ all pages	19-Jan-2025
│ Comm	19-Jan-2025
│ Add your link // 添加友链	26-Aug-2024
│ Comments on static blogs - the right way	03-Dec-2023
│ Copying	15-Oct-2023
│ Privacy and Data Collection	09-Oct-2023
│ About	07-Jun-2020
│ PubKey	07-Jun-2020
│ 谁是 shrik3	07-Jun-2020
IRL everyday stuffs/
│ scams	28-Jun-2025
│ Wissen führen!	12-Jun-2025
│ can I survive a month with 100 Euros for food?	12-Jun-2025
│ Kunststoff	30-Jan-2025
│ Koffein	14-Sep-2024
Readings/
│ ongoing: Designing Freedom (Stafford Beer)	21-Jan-2025
│ ongoing: Interpretation and Overinterpretation (Umberto Eco)	22-Oct-2024
timeline/
log/
│ I don't want to speak to ...	26-Mar-2024
│ WIP? WIP!	13-Oct-2023
│ Live_in	23-May-2023
│ Deconstruct	10-Mar-2022
│ Shells	29-Nov-2021
│ 配乐很好听的动漫	11-May-2021
│ Perfection at the price of humanity	18-Apr-2021
│ 啸叫	13-Apr-2021
│ Christmas trees are stupid	13-Apr-2021
│ 记一次删库	06-Apr-2021
│ 垃圾清理	02-Feb-2021
│ 一点体会	11-Jan-2021
│ 自动机	01-Dec-2020
│ Fri. Downtime	06-Aug-2020
│ A SIMPLE RULE	03-Jun-2020
│ 烤布丁与薄饼	08-Aug-2019
│ 土豆浓汤菜谱	04-Aug-2019
│ THIS IS A DUMPSTER OF TOXICITY	09-Jul-2019
│ Just Random	01-Jun-2019
bits/
│ bits 0x55 - CW 9 - 26, 2025	27-Feb-2025
│ bits 0x54 - Week 35~END 2024	03-Sep-2024
│ bits 0x53 - Week 28~35, 2024	11-Jul-2024
│ bits 0x52 - Week 17~27, 2024 [VOID]	03-Jul-2024
│ bits 0x51 - Calender Week 17, 2024	22-Apr-2024
│ bits 0x50 - Calender Week 16, 2024	16-Apr-2024
│ bits 0x49 - Calender Week 15, 2024	08-Apr-2024
│ bits 0x48 - Calender Week 14, 2024	03-Apr-2024
│ bits 0x47 - Calender Week 13, 2024	24-Mar-2024
│ bits 0x46 - Calender Week 12, 2024	18-Mar-2024
│ bits 0x45 - Calender Week 11, 2024	14-Mar-2024
│ bits 0x44 - Calender Week 10, 2024	10-Mar-2024
│ bits 0x43 - Calender Week 09, 2024 [VOID]	10-Mar-2024
│ bits 0x42 - Calender Week 08, 2024 [VA]	21-Feb-2024
│ bits 0x41 - Calender Week 07, 2024 [VOID]	21-Feb-2024
│ bits 0x40 - Calender Week 06, 2024 [VOID]	05-Feb-2024
│ bits 0x39 - Calender Week 05, 2024	29-Jan-2024
│ bits 0x38 - Calender Week 04, 2024	24-Jan-2024
│ bits 0x37 - Calender Week 03, 2024	16-Jan-2024
│ bits 0x36 - Calender Week 02, 2024 [VA]	13-Jan-2024
│ bits 0x35 - Calender Week 01, 2024	03-Jan-2024
│ bits 0x34 - Calender Week 52, 2023	31-Dec-2023
│ bits 0x33 - Calender Week 51, 2023	17-Dec-2023
│ bits 0x32 - Calender Week 50, 2023 [VOID]	17-Dec-2023
│ bits 0x31 - Calender Week 49, 2023	06-Dec-2023
│ bits 0x30 - Calender Week 48, 2023	26-Nov-2023
│ bits 0x2f - Calender Week 47, 2023	20-Nov-2023
│ bits 0x2e - Calender Week 46, 2023	14-Nov-2023
│ bits 0x2d - Calender Week 45, 2023	09-Nov-2023
│ bits 0x2c - Calender Week 44, 2023	30-Oct-2023
│ bits 0x2b - Calender Week 43, 2023	22-Oct-2023
│ bits 0x2a - Calender Week 42, 2023	17-Oct-2023
vis/
│ this building must be haunted	11-Oct-2024
│ Belgien	07-Sep-2024
│ C _o_ r e^	31-Jul-2024
│ Pieces	28-Nov-2023
│ Dresden	28-Nov-2023
│ a Neon Dream	28-Nov-2023
│ Idols	28-Nov-2023
│ Memes	01-Jan-1970
notes/
│ Synchronisationbegriffe - WIP	11-Nov-2025
│ toolchain and runtimes/
│ │ GNU toolchains	20-Oct-2025
│ │ C Runtime	20-Oct-2025
│ │ cmake notes	10-Dec-2024
│ │ the GNU autosomething	04-Dec-2024
│ │ Makefile	22-May-2020
│ Betriebssysteme (ohne) Sicherheit/
│ teach myself bioinformatics/
│ │ read	28-Feb-2025
│ │ bioshocks (pun intended!)	27-Feb-2025
│ │ glossary	27-Feb-2025
│ algo/
│ │ 快速幂模的两种实现	30-Nov-2020
│ archived/
│ │ CBSE notes	13-Apr-2021
│ │ Vektorraum, Untervektorraum und Spannraum	19-Nov-2020
│ │ Prozess & Thread	10-Nov-2020
│ hw/
│ │ VLIW archs	03-Jun-2025
│ │ SDRAM intro	28-May-2025
│ │ ECC memory and bitflip handling	30-Apr-2025
│ │ device tree (linux) /// WIP	30-Jan-2025
│ │ TSC and High precision time measuring	29-Nov-2024
│ │ Caching Mapping / 缓存映射	08-Jun-2021
│ │ aarch64/
│ │ │ mnemonics	25-Oct-2023
│ │ FPGA stuffs/
│ │ memory and cache/
│ │ │ Memory Model and Formalization	07-May-2025
│ │ │ MC-02h - memory constency intro & sequential consistency	06-May-2025
│ │ │ MC-01h - coherence introduction	05-May-2025
│ │ x86/
│ lang/
│ │ bash/
│ │ │ frequently used	01-Nov-2024
│ │ c lang/
│ │ │ L/R values, reference, copy and move semantics	16-May-2025
│ │ │ C++ std string and string_view	16-May-2025
│ │ │ C++ std::thread (std <= 17)	16-May-2025
│ │ │ C++ lambda	14-May-2025
│ │ │ C with class	12-May-2025
│ │ │ libcommon (todo)	04-Feb-2025
│ │ │ gettext library : i18n for c	04-Feb-2025
│ │ │ c/c++ inline, const and static	28-Jan-2025
│ │ │ dealing with commandline args	28-Jan-2025
│ │ │ C++ hacks	14-Jan-2025
│ │ │ Smart Pointer	15-Dec-2024
│ │ │ modern c features	15-Dec-2024
│ │ │ GCC inline assembly	29-Nov-2024
│ │ │ C++ de-alienation / 祛魅	26-Nov-2024
│ │ │ struct inheritence	04-Oct-2023
│ │ │ {variable scope trick, nested declaring, bitfield}	08-Aug-2022
│ │ │ Const Expression in c++	11-Apr-2022
│ │ │ 指针传参hack	09-Jul-2019
│ │ │ modern CPP/
│ │ │ │ modern cpp features - C++11	15-Dec-2024
│ │ │ │ modern cpp features - C++14	15-Dec-2024
│ │ │ │ modern cpp features - C++17	15-Dec-2024
│ │ │ │ modern cpp features - C++20	15-Dec-2024
│ │ │ │ modern cpp features - overview	15-Dec-2024
│ │ go/
│ │ │ examples all in one	31-Dec-2024
│ │ lua/
│ │ │ learn lua (WIP)	02-Jun-2025
│ │ python/
│ │ │ python package management and virtual env	27-Feb-2025
│ │ rust/
│ │ │ Rust modules structure in a nutshell	05-Jan-2023
│ linux/
│ │ process, thread, task	27-Oct-2025
│ │ serial tty	23-Jan-2025
│ │ linux file permissions	21-Jan-2025
│ │ install linux (Deibian) w/ bare qemu	29-Oct-2024
│ │ {SeLinux, MAC, LSM, DAC, AppArmor}	17-Oct-2024
│ │ device number 1	12-Jul-2020
│ │ device number 2	12-Jul-2020
│ │ tooltips/
│ │ │ input output, file, pipe, redirections and parameters	23-Jan-2025
│ │ │ linux FS tools {mount, overlay, chroot}	30-Oct-2024
│ │ │ disk encryption (ext4)	18-Jul-2020
│ │ │ mount commands	23-Jun-2020
│ microkernel/
│ │ L4RE hands-on : build system	01-Jul-2025
│ │ Genode and Trusted Computing	20-Jun-2025
│ │ L4RE hands-on : language quirks (WIP)	27-May-2025
│ │ L4RE CODE READING : IPC, object, task, low-level	26-May-2025
│ │ L4RE hands-on : adding a package / service (WIP)	23-May-2025
│ │ L4RE hands-on : hello world and boot ISO	19-May-2025
│ │ l4RE hands-on : basic concepts	29-Apr-2025
│ misc/
│ │ statistic tools - 去海边整点统计工具	04-Jul-2025
│ │ Diffie–Hellman key exchange	03-Jun-2025
│ │ the DWARF Debugging Information Format (V5)	04-Mar-2025
│ │ Lambda-calculus: 布尔逻辑	09-Jun-2021
│ │ Lambda 演算	07-Jun-2021
│ │ Extensionality	07-Jun-2021
│ │ IEEE754 单精度浮点数	25-Nov-2020
│ multicore, synchronization and locks/
│ │ The Art of Multiprocessor Programming - Notiz	03-Jul-2025
│ │ Reader/Writer Locks	12-May-2025
│ │ linux futex (fast user-space locking)	11-May-2025
│ │ ia32 instructions and micro-arch for locks	10-May-2025
│ │ some atomic memory operations	08-May-2025
│ │ linux kernel synchronization (WIP)	08-May-2025
│ │ List synchronization, from coarse-grained to non blocking wait-free	08-May-2022
│ │ Quiescent consistency, sequential consistency and linearizability	20-Aug-2021
│ │ Basics of mutual exclusion and locks	29-Apr-2021
│ RDMA / infiniband/
│ │ RDMA 101 - libverbs APIs and hello world	21-Jul-2025
│ │ RDMA 101 - basics	21-Jul-2025
│ system administration/
│ │ frequenctly used	10-Apr-2025
│ │ pleroma maintainece notes	09-Apr-2025
│ │ infrasturctures	04-Feb-2025
│ system tracing and profiling/
│ │ perf cheatsheet	27-Oct-2024
│ tooling/
│ │ container, k8s, docker, podman	08-Sep-2025
│ │ COLLECTION OF DEV TOOLS	03-Feb-2025
│ │ Latex basic	04-May-2021
│ │ GPG Quick Notes	18-Nov-2020
│ │ rsync basic usage	28-Oct-2020
│ │ AWK basic usage	14-Jul-2020
my music/
│ die Todgeweihten interview (chinese)	21-Jun-2021
│ Reflections on the isomorph album (cn+en)	14-Jun-2021
│ Isomorph	11-Jun-2021
│ My music projects - overview (chinese)	07-Jun-2020
│ My music projects - overview and listens	07-Jun-2020
cred/
│ ausland	23-Jun-2025
│ hello	23-Jun-2025
code reading/
│ bits worth learning	17-Feb-2025
│ pv (pipe viewer) - manipulate pipe and stream	17-Feb-2025
│ Bochs code reading, notes and hacks	09-Oct-2024
│ coreutils/
│ │ prologue of main tldr it doesn't matter	28-Jan-2025
│ linux/
│ │ timer interrupt	02-Jun-2025
│ │ Machine Check Handling (AMD64)	10-May-2025
│ │ fix my bluetooth keyboard/
│ │ misc/
│ │ │ TODOs in linux code reading	29-Jan-2025
│ │ │ per cpu variables	29-Jan-2025
│ │ │ snippets, quick facts and takeaways	22-Jan-2025
│ │ │ Booting Process (WIP)	22-Jan-2025
│ │ │ interesting places to look at	06-May-2024
│ │ patches/
│ │ │ x86: Put hot per CPU variables into a struct	29-Jan-2025
│ │ │ pack struct file for cacheline optimizations	21-Jan-2025
│ │ sync/
│ │ │ spinlock impl	13-May-2025
│ │ │ CONFIG_DEBUG_SPINLOCK	13-May-2025
│ │ │ lockdep	13-May-2025
│ │ │ R/W lock impl	13-May-2025
│ │ │ RCU fundamentals	17-Oct-2024
Bin/