Joachim-jenke-0d01@rwth-aachen.de: Change ThreadSanitizer link to internal page

2024-07-04T11:50:00Z

Change ThreadSanitizer link to internal page

Daniel-schurhoff-de23@rwth-aachen.de at 14:17, 3 September 2019

2019-09-03T14:17:59Z

Thomas-gruber-5537@uni-erlangen.de: Created page with "== Compiler Sanitizers == The C/C++ compilers Clang/LLVM and GCC support so-called sanitizers. These sanitizers are built into the application code and track the execution at..."

2019-06-06T17:18:32Z

Created page with "== Compiler Sanitizers == The C/C++ compilers Clang/LLVM and GCC support so-called sanitizers. These sanitizers are built into the application code and track the execution at..."

New page

== Compiler Sanitizers ==

The C/C++ compilers Clang/LLVM and GCC support so-called sanitizers. These sanitizers are built into the application code and track the execution at runtime to report execution errors. There are currently four interesting sanitizers:

* AddressSanitizer and LeakSanitizer
* ThreadSanitizer
* MemorySanitizer

=== AddressSanitizer and LeakSanitizer ===
The AddressSanitizer is a memory error detector for C/C++. The LeakSanitizer detects memory leaks and is part of the AddressSanitizer for many operating systems. They detect following errors:

* Use after free (dangling pointer dereference)
* Heap buffer overflow
* Stack buffer overflow
* Global buffer overflow
* Use after return
* Use after scope
* Initialization order bugs
* Memory leaks

In order to activate it for your code, compile it with: 
<code>$CC -fsanitize=address -fno-omit-frame-pointer ...</code> 
The <code>-fno-omit-frame-pointer</code> is used for better readability of the error output.

The AddressSanitizer cannot be combined with the ThreadSanitizer

For further information: [https://github.com/google/sanitizers/wiki/AddressSanitizer AddressSanitizer] and [https://github.com/google/sanitizers/wiki/AddressSanitizerLeakSanitizer LeakSanitizer]

=== ThreadSanitizer ===
ThreadSanitizer is a data race detector for C/C++. Data races are one of the most common and hardest to debug types of bugs in concurrent systems. A data race occurs when two threads access the same variable concurrently and at least one of the accesses is write.

In order to activate it for your code, compile it with: 
<code>$CC -fsanitize=thread ...</code> 

For further information: [https://github.com/google/sanitizers/wiki/ThreadSanitizerCppManual ThreadSanitizer]

=== MemorySanitizer ===
MemorySanitizer is a detector of uninitialized memory reads in C/C++ programs.

Uninitialized values occur when stack- or heap-allocated memory is read before it is written. MemorySanitizer detects cases where such values affect program execution.

MemorySanitizer is bit-exact: it can track uninitialized bits in a bitfield. It will tolerate copying of uninitialized memory, and also simple logic and arithmetic operations with it. In general, MemorySanitizer silently tracks the spread of uninitialized data in memory, and reports a warning when a code branch is taken (or not taken) depending on an uninitialized value.

In order to activate it for your code, compile it with: 
<code>$CC -fsanitize=memory -fPIE -pie ...</code> 
The <code>-fno-omit-frame-pointer</code> is used for better readability of the error output.

For further information: [https://github.com/google/sanitizers/wiki/MemorySanitizer MemorySanitizer]

@@ Line 34: / Line 34: @@
 <code>$CC -fsanitize=thread ...</code><br>
-For further information: [https://github.com/google/sanitizers/wiki/ThreadSanitizerCppManual ThreadSanitizer]
+For further information: [[ThreadSanitizer]]
 === MemorySanitizer ===

← Older revision		Revision as of 14:17, 3 September 2019
Line 1:		Line 1:
		+	[[Category:HPC-Developer]]
	== Compiler Sanitizers ==		== Compiler Sanitizers ==

Compiler Sanitizers - Revision history

Joachim-jenke-0d01@rwth-aachen.de: Change ThreadSanitizer link to internal page

Daniel-schurhoff-de23@rwth-aachen.de at 14:17, 3 September 2019

Thomas-gruber-5537@uni-erlangen.de: Created page with "== Compiler Sanitizers == The C/C++ compilers Clang/LLVM and GCC support so-called sanitizers. These sanitizers are built into the application code and track the execution at..."