All images and fonts placed here to

preload them into the browser cache

Nexa Text Regular

Nexa Text Bold

Nexa Text Italic

Nexa Text Bold Italic

Nexa Regular

Nexa Bold

Nexa Italic

Nexa Bold Italic

 #include <random_code>
using in_cpp;
 
to preload() {
 // the monospace
 font as = well;
}

GCC, LLVM, ICC	-O2 or -O3
MSVC	/Ox or /O2

GCC, LLVM, ICC	-Os
MSVC	/O1

GCC, LLVM, ICC	-march=native -mtune=native
MSVC	/arch:IA32 or /arch:SSE or /arch:SSE2 or /arch:AVX or /arch:AVX2 or /arch:AVX512

GCC, LLVM	-mcpu=native
MSVC	/arch:ARMv7VE or /arch:VFPv4 or /arch:armv8.0 ... or /arch:armv8.8

GCC, LLVM	-ffast-math (included in -Ofast)
MSVC	/fp:fast
ICC	-fp-model=fast

GCC, LLVM, ICC	-fno-exceptions
MSVC	/EHs-c- /D_HAS_EXCEPTIONS=0

GCC, LLVM, ICC	-fno-rtti
MSVC	/GR-

GCC, LLVM	-flto
MSVC	/GL
ICC	-ipo

GCC, LLVM	-fprofile-generate
MSVC	/GENPROFILE
ICC	-prof-gen

GCC, LLVM	-fprofile-use
MSVC	/USEPROFILE
ICC	-prof-use

C++23	[[assume(condition)]];
GCC	if (!condition) __builtin_unreachable();
MSVC, ICC	__assume(condition);
LLVM	__builtin_assume(condition);

[[assume(condition)]];	assert(condition);
Condition must be true	Condition must be true
For the optimiser	For the programmer
If !condition then Undefined Behaviour	If !condition then std::abort() in Debug Mode noop in Release Mode

GCC, LLVM, ICC	__attribute__((malloc))
MSVC	__declspec(restrict)

GCC, LLVM, ICC	__attribute__((pure)) or [[gnu::pure]]
MSVC	Not Supported

GCC, LLVM, ICC	__attribute__((pure)) or [[gnu::pure]]
MSVC	Not Supported

GCC, LLVM, ICC	__attribute__((const)) or [[gnu::const]]
MSVC	Not Supported

All images and fonts placed here to preload them into the browser cache Nexa Text Regular Nexa Text Bold Nexa Text Italic Nexa Text Bold Italic Nexa Regular Nexa Bold Nexa Italic Nexa Bold Italic # include <random_code> using in_cpp; to preload () { // the monospace font as = well; }

Your Performance Todo List: The Most Important Performance Opportunities and Pitfalls to Remember About

By Jan Bielak

Your Performance Todo List: The Most Important Performance Opportunities and Pitfalls to Remember About

This is the interactive slide deck for my CppCon 2022 talk. Writing efficient programs is hard. This is because it requires a lot of knowledge, experience and strategic thinking. There have been many talks on optimization and often each addresses a single concept. Being able to achieve a bird’s eye view of factors affecting performance often requires many hours of researching the topic. To lessen the mental burden of optimizing programs, I have picked out the techniques, I believe are most important. During the talk, I will present them in an organized manner and provide practical examples of how they can be applied. I will first discuss what I believe are the main goals efficient programs strive to achieve. Then, I will present the general methods of achieving those goals. Then, for the majority of the talk, we will discuss a few dozen performance opportunities. For each of them, I will explain the underlying mechanism of how the optimisation works. I will avoid bluntly giving guidelines to follow without explanation. Each of the techniques naturally comes with its costs, and those will be discussed as well. I will additionally discuss various performance pitfalls. These are sometimes called “premature pessimisations” in contrast to the often used term of “premature optimizations”. I will show examples of optimizations which do not incur any cost on program readability or ma

3 years ago
1,888

Jan Bielak

janbielak.com

	std::vector<float>
	get_mean_deltas(std::vector<float> data)
	{
	float sum = 0;
	for (auto&& num : data)
	sum += num;

	for (auto& num : data)
	num -= sum / data.size();
	return data;
	}

	std::vector<float>
	get_mean_deltas(std::vector<float> data)
	{
	const float sum = std::accumulate(
	data.begin(),
	data.end(),
	0.0f
	);

	for (auto& num : data)
	num -= sum / data.size();
	return data;
	}

	std::vector<float>
	get_mean_deltas(std::vector<float> data)
	{
	const float sum = std::accumulate(
	data.begin(),
	data.end(),
	0.0f
	);

	const float __mean = sum / data.size();
	for (auto& num : data)
	num -= __mean;
	return data;
	}

	struct {
	/* ... */
	bool fill;
	} _internal__state;

	void set_draw_mode_filled();
	void set_draw_mode_wireframe();

	void draw_mesh(const mesh* m) {
	for (const primitive* prim = m->begin(); prim != m->end(); ++prim) {
	if(_internal__is_frontfacing(*prim)) {
	if (_internal__state.fill) {
	_internal__draw_prim_filled(*prim);
	}
	else {
	_internal__draw_prim_wireframe(*prim);
	}
	}
	}
	}

	struct {
	/* ... */
	bool fill;
	} _internal__state;

	void set_draw_mode_filled();
	void set_draw_mode_wireframe();

	void draw_mesh(const mesh* m) {
	for (const primitive* prim = m->begin(); prim != m->end(); ++prim) {
	if(_internal__is_frontfacing(*prim)) {
	if (_internal__state.fill) {
	_internal__draw_prim_filled(*prim);
	}
	else {
	_internal__draw_prim_wireframe(*prim);
	}
	}
	}
	}

	#include <random_code>
	using in_cpp;

	to preload() {
	// the monospace
	font as = well;
	}

	void draw_mesh(const mesh* m) {
	for (const primitive* prim = m->begin(); prim != m->end(); ++prim)
	if(_internal__is_frontfacing(*prim))
	if (_internal__state.fill)
	_internal__draw_prim_filled(*prim);
	else
	_internal__draw_prim_wireframe(*prim);
	}

	void draw_mesh(const mesh* m) {
	const bool fill = _internal__state.fill;
	for (const primitive* prim = m->begin(); prim != m->end(); ++prim)
	if(_internal__is_frontfacing(*prim))
	if (fill)
	_internal__draw_prim_filled(*prim);
	else
	_internal__draw_prim_wireframe(*prim);
	}

	template <typename T>
	class simple_optional {
	T data;
	bool has_data;
	public:
	/* *** */
	T& value() {
	if (!has_data)
	throw bad_optional_access();
	return data;
	}
	const T& value() const {
	if (!has_data)
	throw bad_optional_access();
	return data;
	}
	};

	struct DebugInfo {
	std::string name;
	time_point creation;
	size_t use_cnt;
	}

	class DescriptorSet {
	VkDescriptorSet handle;
	DebugInfo debug;

	// guaranteed to outlive,
	// not dangling
	const Device& device;
	public:
	// ...
	};

Linux	pthread_set_affinity
Windows	SetThreadAffinityMask
macOS	thread_policy_set with thread_affinity_policy_t

Linux	pthread_setschedprio
Windows	SetThreadPriority
macOS	setThreadPriority (Objective C)

Static Linking	Dynamic Linking