Moving a project to C++ named Modules--Cameron DaCamara

By Adrien Hamelin | Aug 13, 2021 12:27 PM | Tags: c++20

If you can, start using them!

Moving a project to C++ named Modules

by Cameron DaCamara

From the article:

There is a lot of hype (and perhaps restraint) to using modules in projects. The general blocker tends to be build support, but even with good build support there is a distinct lack of useful resources for practices around moving projects to using named modules (not just header units). In this blog we will take a small project I created, analyze its components, draft up a plan for modularizing it, and execute that plan...

Variadic Templates or the Power of Three Dots--Rainer Grimm

By Adrien Hamelin | Aug 13, 2021 12:24 PM | Tags: c++11

The series contine.

Variadic Templates or the Power of Three Dots

by Rainer Grimm

From the article:

A variadic template is a template that can have an arbitrary number of template parameters. This feature may seem magical to you if you see it the first time. So, let me demystify variadic templates...

HPX V1.7.1 released -- STE||AR Group

By Hartmut Kaiser | Aug 13, 2021 08:49 AM | Tags: performance parallelism heterogeneous computing distributed computing concurrency c++20 c++17 c++14 c++11

The STE||AR Group has released V1.7.1 of HPX -- A C++ Standard library for parallelism and concurrency.

HPX V1.7.1 Released

The newest version of HPX (V1.7.1) is now available for download! This release fixes minor problems found after the version 1.7.0. It fixes a bug in the internals of actions, adds a version check to the new Asio dependency, and slightly improves the performance of spinlocks among other minor changes. Importantly, the experimental hpx::execution::simdpar execution policy introduced in 1.7.0 was renamed to hpx::execution::par_simd for consistency with the standard parallel execution policies. While this is a breaking change in a patch release, we felt it was important to make this adaptation as soon as possible. The full list of improvements, fixes, and breaking changes can be found in the release notes.

    HPX is a general purpose parallel C++ runtime system for applications of any scale. It implements all of the related facilities as defined by the C++ Standard. As of this writing, HPX provides one of the only widely available open-source implementation of the new C++17 parallel algorithms. Additionally, HPX implements functionalities proposed as part of the ongoing C++ standardization process, such as large parts of the features related parallelism and concurrency as specified by the upcoming C++20 Standard, the C++ Concurrency TS, Parallelism TS V2, data-parallel algorithms, executors, senders/receivers and many more. It also extends the existing C++ Standard APIs to the distributed case (e.g. compute clusters) and for heterogeneous systems (e.g. GPUs).

    HPX seamlessly enables a new Asynchronous C++ Standard Programming Model that tends to improve the parallel efficiency of our applications and helps reducing complexities usually associated with parallelism and concurrency.

CppCon 2020 The Surprising Costs of void() (and Other Not-Quite-Innocuous Evils)--Patrice Roy

By Adrien Hamelin | Aug 11, 2021 11:51 AM | Tags: None

Registration is now open for CppCon 2021, which starts on October 24 and will be held both in person and online. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from our most recent in-person conference in 2019 and our online conference in 2020. Here’s another CppCon talk video we hope you will enjoy – and why not register today for CppCon 2021 to attend in person, online, or both!

The Surprising Costs of void() (and Other Not-Quite-Innocuous Evils)

by Patrice Roy

Summary of the talk:

There are some things that might pass us by without us noticing them as evil or, as they have come to be known, Bad Code Smells.

Many of these little things are acceptable in some cases, and thus pass unnoticed in some code reviews. They are respectful of language rules, and thus pass unnoticed through the compiler's virtual hands. They might even lead to working code... and if it works, it's fine, no?

The idea for this talk came about when discussing with colleagues about such suspicious code and coding patterns, and hearing such questions as "but why is that a problem?". It's about those little evils that creep in code and poison our practice in subtle ways (making memory consumption higher than it should be, making execution slower than it should be, making reuse harder than it should be, etc.).

How to Parallelise CSV Reader - C++17 in Practice--Bartlomiej Filipek

By Adrien Hamelin | Aug 11, 2021 11:44 AM | Tags: performance c++17

Would do it the same way?

How to Parallelise CSV Reader - C++17 in Practice

by Bartlomiej Filipek

Friom the article:

At C++Stories (and in my C++17 book) you can find several articles on Parallel Algorithms introduced in C++17. The examples included in those posts were usually relatively straightforward. How about writing something larger?

In this text, you’ll see how to build a tool that works on CSV files, parses lines into sales records and then performs calculations on the data.

You’ll see how easy it is to add parallel execution to selected algorithms and have a performance improvement across the whole application (for example 4.5x on 6 cores, including file loading). In the end, we’ll discuss problems that we found along the way and possible future enhancements.

Here’s the plan:

• How to build an application that loads CSV files
• How to efficiently use parallel algorithms
• How to use std::filesystem library to gather required files
• How to use other C++17 library features like std::optional, conversion routines - std::from_chars and string_view
• Where to add [[nodiscard]] and improve code readability

Let’s go...

Template Instantiation--Rainer Grimm

By Adrien Hamelin | Aug 11, 2021 11:42 AM | Tags: basics

The series continue.

Template Instantiation

by Rainer Grimm

From the article:

Template instantiation is the creation of a concrete function or a concrete class out of a function template or class template. The creation of template instantiation can be implicit (compiler-generated) or explicit (user-provided)...

PVS-Studio for JetBrains CLion: ad astra per aspera

By Andrey Karpov | Aug 11, 2021 01:29 AM | Tags: static code analysis sast pvs-studio plugin jetbrains devtool clion bugs

The PVS-Studio analyzer already has plugins for such IDEs from JetBrains as Rider, IntelliJ IDEA and Android Studio. Somehow we missed another IDE - CLion. The time has come to make amends!

PVS-Studio for JetBrains CLion: ad astra per aspera

by Evgeniy Ovsyannikov, Sergey Vasiliev

From the article:

Here's an answer to the question that we are discussing - PVS-Studio and CLion collaboration will let us detect more errors at the writing code stage. CLion highlights the errors on the fly, but at the same time is limited in the analysis capabilities. PVS-Studio doesn't highlight errors immediately, but it can perform deeper analysis. Note that PVS-Studio has an incremental analysis – the mode that checks only the changed files.

Adding a book section to Meeting C++

By Meeting C++ | Aug 11, 2021 12:59 AM | Tags: meetingcpp community c++20 c++17 books

Meeting C++ has now its own C++ book section:

Adding a book section to Meeting C++

by Jens Weller

From the article:

The section offers a listing of current C++ books, currently 14 books by various authors such as Bjarne Stroustrup or Rainer Grimm! More books will be listed in the future, as not all authors had yet time to list their books. July/August is a holiday month after all, though that might give you the time to read a book!

Intermodular analysis of C++ projects in PVS-Studio

By Andrey Karpov | Aug 10, 2021 02:17 AM | Tags: pvs-studio intermodular analysis data flow code analysis

Recently PVS-Studio has implemented a major feature—we supported intermodular analysis of C++ projects. This article covers our and other tools' implementations. You'll also find out how to try this feature and what we managed to detect using it.

Intermodular analysis of C++ projects in PVS-Studio

by Oleg Lisiy, Sergey Larin

From the article:

We can't apply the approach above to the PVS-Studio tool. Our analyzer's main difference from compilers is that it doesn't form intermediate representation that is abstracted from the language context. Therefore, to read a symbol from another module, the tool has to translate it again and represent a program as in-memory data structures (parse tree, control flow graph, etc). Data flow analysis may also require parsing the entire dependency graph by symbols in different modules. Such a task may take a long time. So, we collect information about symbols (in particular in data flow analysis) using semantic analysis. We need to somehow save this data separately beforehand. Such information is a set of facts for a particular symbol. We developed the below approach based on this idea.

CppCon 2019 The Dawn of a New Error--Phil Nash

By Adrien Hamelin | Aug 9, 2021 01:17 PM | Tags: community

Registration is now open for CppCon 2021, which starts on October 24 and will be held both in person and online. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from our most recent in-person conference in 2019 and our online conference in 2020. Here’s another CppCon talk video we hope you will enjoy – and why not register today for CppCon 2021 to attend in person, online, or both!

The Dawn of a New Error

by Phil Nash

Summary of the talk:

As a community we've tried many different ways to express, propagate and handle error conditions in our code over the years. Each seem to have different trade-offs, with none being perfect in all cases.

This presentation is the follow-up to my earlier talk, "Option(al) Is Not a Failure", where I surveyed existing error-handling approaches and score them against each other, leading up to the new proposal, p0709, "Zero-overhead deterministic exceptions".

We'll summarise some of that background so we're all on the same page, but in this talk we're going to dig into the proposal in more depth - and look at the supporting proposals, p1028 (std::error) and p1029 ([[move relocates]]) and others. We'll also comment similar mechanisms in other languages, notably Swift, to get an idea of how it might work out in practice.