Take control of your vcpkg dependencies with versioning support--Victor Romero

By Adrien Hamelin | Feb 19, 2021 12:48 PM | Tags: community

A new feature.

Take control of your vcpkg dependencies with versioning support

by Victor Romero

From the article:

We have an exciting new feature to announce in vcpkg: the long-awaited and highly requested package versioning! This feature makes it possible to install specific versions of dependencies and control installed versions over time. In order to use this feature, a vcpkg.json manifest file must be present in your repo to declare dependencies. Versioning is not currently available for libraries installed via the command line (i.e. vcpkg install library_name commands). The versioning feature is completely optional – you can choose not to specify library versions, and vcpkg will pick the most appropriate set of compatible versions for your dependencies from its baseline catalog. For now, we are considering this feature experimental. Please give us your feedback and let us know how we can improve...

Introduction to GPU Programming with CUDA and Thrust -- Richard Thomson

By Legalize Adulthood | Feb 18, 2021 12:44 PM | Tags: None

Utah C++ Programmers has released a new video from their February meeting.

Introduction to GPU Programming with CUDA and Thrust

by Richard Thomson

From the video description:

High-performance computing is now dominated by general-purpose graphics processing unit (GPGPU) oriented computations. How can we leverage our knowledge of C++ to program the GPU?

NVIDIA's answer to general-purpose computing on the GPU is CUDA. CUDA programs are essentially C++ programs, but have some differences. CUDA comes as a Toolkit SDK containing a number of libraries that exploit the resources of the GPU: fast Fourier transforms, machine learning training and inference, etc. Thrust is a C++ template library for CUDA.

In this month's meeting, Richard Thomson will present a brief introduction to CUDA with the Thrust library to program the GPU.

Programming the GPU with CUDA is a huge topic covered by lots of libraries, tutorials, videos, and so-on, so we will only be able to present an introduction to the topic. You are encouraged to explore more on your own!

YouTube: https://www.youtube.com/watch?v=tbb835UFRQ4

Preconditions, Postconditions, Invariants - How They Help Write Robust Programs

By Andrzej Krzemienski | Feb 18, 2021 12:43 PM | Tags: None

An introduction to preconditions, postconditions and invariants.

Preconditions, Postconditions, Invariants –- How They Help Write Robust Programs

by Andrzej Krzemieński

From the video description:

Preconditions, postconditions, and invariants are part of what is often called Design by Contract, or Contract Programming. Even if you haven't heard of them, you are probably using them already. In this talk, we are going to see what they are, and how people and tools can make use of them.

unique_ptr, shared_ptr, weak_ptr, or reference_wrapper for class relationships -- Hitesh Kumar

By Hitesh Kumar | Feb 18, 2021 12:35 PM | Tags: None

Expressing class relationships with unique_ptr, shared_ptr, weak_ptr, and reference_wrapper.

unique_ptr, shared_ptr, weak_ptr, or reference_wrapper for class relationships

by Hitesh Kumar

From the article:

Classes communicate with each other by having handles as members that refer to other classes. The choice of those referring-handles (e.g., pointers or references) is mostly driven by ownership or control-over-lifetime semantics.

Why PVS-Studio Uses Data Flow Analysis: Based on Gripping Error in Open Asset Import Library

By Andrey Karpov | Feb 18, 2021 10:20 AM | Tags: value range analysis static code analysis pvs-studio data flow analysis cwe-571 bugs

An essential part of any modern static code analyzer is data flow analysis. However, from an outside perspective, the use of data flow analysis and its benefit is unclear.

Why PVS-Studio Uses Data Flow Analysis: Based on Gripping Error in Open Asset Import Library

by Andrey Karpov

From the article:

It all started with checking the latest version of the Qt 6 library. There was a separate usual article on this, where I'd described 77 errors found. It turned out that at first, I decided to flip through the report, not excluding the third-party libraries' warnings. In other words, I didn't exclude the warnings related to \src\3rdparty in the settings. It so happened that I immediately ran up against a gripping error example in the Open Asset Import Library. So, I decided to write this extra little note about it.

Modern C++: Safety and Expressiveness with override and final

By Adrien Hamelin | Feb 18, 2021 08:25 AM | Tags: c++11

Back to basics.

Modern C++: Safety and Expressiveness with override and final

by Bartlomiej Filipek

From the article:

While C++11 is with us for a decade now, it’s good to go back and recall some of its best features. Today I’d like to consider override and final keywords which add a crucial safety when you build class hierarchies with lots of virtual member functions.

See how to prevent common bugs, and how to leverage tools to make your code safer...

An Improved Thread with C++20--Rainer Grimm

By Adrien Hamelin | Feb 18, 2021 08:21 AM | Tags: c++20

More about c++20.

An Improved Thread with C++20

by Rainer Grimm

From the article:

std::jthread stands for joining thread. In addition to std::thread (C++11), std::jthread automatically joins in its destructor and can cooperatively be interrupted. Read in this post to know why std::jthread should be your first choice...

Colony – A brief history of timing--Matt Bentley

By Adrien Hamelin | Feb 18, 2021 08:18 AM | Tags: None

A different container.

Colony – A brief history of timing

by Matt Bentley

From the article:

Back in 2014 I began designing a game engine. Experienced programmers and curmudgeonly lecturers will tell you that if you make a game engine, you’ll never make a game – which is true, but sort of irrelevant. You will learn so much from making a game engine, you probably won’t care about the game by the end of it. The main reason I wanted to develop a game engine was that I was tired of seeing very basic 2D games with incredibly bad performance even on fast computers. If we got 15 frames-per-second on Intel 386 processors in the 1990s, why was it so hard for modern 2D games to achieve the same speed on exponentially-better hardware?

Colony – A brief history of timing

By Adrien Hamelin | Feb 18, 2021 07:51 AM | Tags: None

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

By Hartmut Kaiser | Feb 18, 2021 07:18 AM | Tags: performance parallelism heterogeneous computing distributed computing concurrency c++20 c++17 c++14 c++11

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

HPX V1.6.0 Released

The newest version of HPX (V1.6.0) is now available for download! This release continues the focus on C++20 conformance with multiple new algorithms adapted to be C++20 conformant and becoming customization point objects (CPOs). We have added experimental support for HIP, allowing existing CUDA features to now be compiled with hipcc and run on AMD GPUs as well. We have also continued improving the performance of the parallel executors, and added an experimental fork-join executor. 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 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, 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.