Jingga/Developer-Guide
1
0
Fork 0
mirror of https://github.com/Karaka-Management/Developer-Guide.git synced 2026-02-09 17:08:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update cpp.md

Browse Source 
Signed-off-by: Dennis Eichhorn <spl1nes.com@googlemail.com>
This commit is contained in:
Dennis Eichhorn 2024-08-05 19:35:24 +02:00 committed by GitHub
parent 9943f6a8ef
commit 20a754151b
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 21 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
standards/cpp.md
View File

@ -36,6 +36,27 @@ When writing code keep the following topics in mind:
* atomics vs locking (mutex) * atomics vs locking (mutex)
* Cache line sharing between CPU cores * Cache line sharing between CPU cores
### Branching / Branchless programming
Branched code
```c++
for (int i = 0; i < N; i++)
if (a[i] < 50) {
s += a[i];
}
}
```
Branchless code
```c++
for (int i = 0; i < N; i++)
s += (a[i] < 50) * a[i];
}
```
### Cache line sharing between CPU cores ### Cache line sharing between CPU cores
When working with multi-threading you may choose to use atomic variables and atomic operations to reduce the locking in your application. You may think that a variable value `a[0]` used by thread 1 on core 1 and a variable value `a[1]` used by thread 2 on core 2 will have no performance impact. However, this is wrong. Core 1 and core 2 both have different L1 and L2 caches BUT the CPU doesn't just load individual variables, it loads entire cache lines (e.g. 64 bytes). This means that if you define `int a[2]`, it has a high chance of being on the same cache line and therfore thread 1 and thread 2 both have to wait on each other when doing atomic writes. When working with multi-threading you may choose to use atomic variables and atomic operations to reduce the locking in your application. You may think that a variable value `a[0]` used by thread 1 on core 1 and a variable value `a[1]` used by thread 2 on core 2 will have no performance impact. However, this is wrong. Core 1 and core 2 both have different L1 and L2 caches BUT the CPU doesn't just load individual variables, it loads entire cache lines (e.g. 64 bytes). This means that if you define `int a[2]`, it has a high chance of being on the same cache line and therfore thread 1 and thread 2 both have to wait on each other when doing atomic writes.