By Adrien Hamelin | Jul 25, 2018 12:08 PM | Tags: performance c++17
The usefullness of views.
Performance of std::string_view vs std::string from C++17
by Bartlomiej Filipek
From the article:
How much is std::string_view faster than standard std::string operations?
Have a look at a few examples where I compare std::string_view against std::string.
By Adrien Hamelin | Jul 23, 2018 02:10 PM | Tags: performance experimental
Do you want this?
Announcing “trivially relocatable”
by Arthur O’Dwyer
From the article:
Frequent users of Compiler Explorer, a.k.a. godbolt.org, may have noticed that a few days ago a new compiler appeared in its dropdown menu. “x86-64 clang (experimental P1144)” is a branch of Clang which I have patched to support the concept of “trivially relocatable types,” as described in my C++Now 2018 talk and as proposed for standardization in my upcoming paper P1144 “Object relocation in terms of move plus destroy” (coauthored with Mingxin Wang)...
By Adrien Hamelin | Jul 23, 2018 02:05 PM | Tags: performance
Avoiding copies.
How to Construct C++ Objects Without Making Copies
by Miguel Raggi
From the article:
C++ references are a powerful but tricky tool: used correctly, they can improve performance with little impact on the clarity of code. But used badly, they can hide performance issues, or even send a peaceful program into the realm of undefined behaviour.
In this post, we will explore how to use the various references of C++ to minimize copies when constructing an object that holds a value, and how in some cases we can even reach zero copies.
This article assumes that you’re familiar with move semantics, lvalue, rvalue and forwarding references. If you’d like to be refreshed on the subject, you can take a look at lvalues, rvalues and their references.
By Jason Turner | Jul 23, 2018 10:31 AM | Tags: performance efficiency basics
Episode 125 of C++ Weekly.
The Optimal Way To Return From A Function
by Jason Turner
About the show:
In this episode of C++ Weekly Jason investigates the possible methods that one of two string values might be returned from a function. Which option is best? Which option can the compiler optimize the most? Do we take one return path or multiple return paths? Should a ternary be used?
By Adrien Hamelin | Jul 11, 2018 01:23 PM | Tags: performance community
Have you registered for CppCon 2018 in September? Registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:
Delegate this! Designing with delegates in modern C++
by Alfred Bratterud
Summary of the talk:
Designing a fast IP stack from scratch is hard. Using delegates made it all easier for IncludeOS, the open source library operating system written from scratch in modern C++. Our header-only delegates are just as fast as C-style function pointers, compatible with std::function, and allows any object to delegate work to stateful member functions without knowing anything about the class they belong to. We use delegates for everything from routing packets to creating REST endpoints, and most importantly to tie the whole IP stack together. In this talk we’ll show you how we use delegates in IncludeOS, discuss pitfalls and alternatives, and give you all you need to get started.
By Adrien Hamelin | Jul 9, 2018 01:26 PM | Tags: performance community
Have you registered for CppCon 2018 in September? Registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:
Coroutines: what can't they do?
by Toby Allsopp
Summary of the talk:
Coroutines are coming. They're coming for your asynchronous operations. They're coming for your lazy generators. This much we know. But once they're here, will they be satisfied with these offerings? They will not. They will require feeding, lest they devour our very souls. We present some fun ways to keep their incessant hunger at bay. I, for one, welcome our new coroutine overlords.
The Coroutines Technical Specification is an experimental extension to the C++ language that allows functions to be suspended and resumed, with the primary aim of simplifying code that invokes asynchronous operations. We present a short introduction to Coroutines followed by some possibly non-obvious ways they can help to simplify your code.
Have you ever wanted to elegantly compose operations that might fail? Coroutines can help. Have you ever wished for a zero-overhead type-erased function wrapper? Coroutines can help. We show you how and more.
By Adrien Hamelin | Jul 2, 2018 12:51 PM | Tags: performance community
Have you registered for CppCon 2018 in September? Early bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:
Concurrency, Parallelism and Coroutines
by Anthony Williams
Summary of the talk:
C++17 is adding parallel overloads of most of the Standard Library algorithms. There is a TS for Concurrency in C++ already published, and a TS for Coroutines in C++ and a second TS for Concurrency in C++ in the works.
What does all this mean for programmers? How are they all related? How do coroutines help with parallelism?
This session will attempt to answer these questions and more. We will look at the implementation of parallel algorithms, and how continuations, coroutines and work-stealing fit together. We will also look at how this meshes with the Grand Unified Executors Proposal, and how you will be able to take advantage of all this as an application developer.
By Adrien Hamelin | Jul 2, 2018 12:39 PM | Tags: performance c++17
Now with some more numbers.
Parallel STL And Filesystem: Files Word Count Example
by Bartlomiej Filipek
From the article:
Last week you might have read about a few examples of parallel algorithms. Today I have one more application that combines the ideas from the previous post.
We’ll use parallel algorithms and the standard filesystem to count words in all text files in a given directory...
By Adrien Hamelin | Jun 27, 2018 12:13 PM | Tags: performance llvm
Today we look at compile time performance.
The surprisingly high cost of static-lifetime constructors
by Arthur O’Dwyer
From the article:
I was looking at HyperRogue again this week (see my previous post). It has a really nice localization framework: every message in the game can be translated just by adding a lookup entry to a single file (like, for the Czech translation, you add entries to language-cz.cpp); and then during the build process, all the language-??.cpp files are collated together and used to produce a single language-data.cpp file with a lookup table from each English message to the same message in every other language. (Seeing all the messages at once allows us to report on how “complete” each translation is, relative to the others.)...
By Adrien Hamelin | Jun 25, 2018 12:31 PM | Tags: performance c++17
Do you know them?
Examples of Parallel Algorithms From C++17
by Bartlomiej Filipek
From the article:
MSVC (VS 2017 15.7, end of June 2018) is as far as I know the only major compiler/STL implementation that has parallel algorithms. Not everything is done, but you can use a lot of algorithms and apply std::execution::par on them!
Have a look at few examples I managed to run...