Unlocking the Power of Parallelism: Intel's Parallel STL for C++17

Table of Contents

• Introduction
• Overview of C++ 17 Execution Policies
• Using Intel's Parallel STL Library
• Tutorial: Benchmarks for Accelerated Parallel STL Library on StrongNet Clusters
• The Standard Template Library (STL)
• Parallelizing the STL: Why it Matters
• Available Implementations of Parallel STL
• Third-Party C++ Libraries for Parallel Computing
• C++ 17 Execution Policies: Explained
• Pros and Cons of Intel's Parallel STL

Introduction

In this article, we will delve into the topic of C++ 17 parallel algorithms and explore how they can be used with Intel's Parallel STL library. We will begin with an overview of the C++ 17 execution policies, followed by a demonstration of how to utilize Intel's implementation of parallel STL. Additionally, we will provide a tutorial along with benchmarks for the accelerated parallel STL library on StrongNet clusters. To follow along with the tutorial, you can find the necessary files in the Get A Shark Net Lab repository. Please note that you will need your ShortNet credentials to log into the Get server. So, let's start by understanding the fundamentals of the Standard Template Library (STL).

The Standard Template Library (STL)

The STL is a standard library that has been a staple for C++ programmers for over two decades. It provides a collection of standard containers and algorithms that simplify programming tasks. The STL consists of four main components: containers, iterators, algorithms, and functions. Containers are used to store data in different data structures, while iterators are used to traverse and manipulate the data in these containers. Algorithms, as the name suggests, perform various operations on the data, such as sorting or searching. And finally, functions provide additional utility for algorithms, including the ability to accept lambdas or custom functions.

Parallelizing the STL: Why it Matters

The idea behind having a parallel STL is simple yet powerful. Since the STL is already familiar to most C++ programmers and widely used in existing programs, the introduction of a parallel version allows for easy integration of parallel computing capabilities with minimal code changes. This means that any program leveraging the STL can be transformed into a parallel version with just a few modifications. There are a few available implementations of parallel STL, with Intel's Parallel STL library being one of the popular choices.

Available Implementations of Parallel STL

There are two main categories of implementations for parallel STL: C++ 11 parallel algorithms and C++ 17 parallel algorithms. The C++ 11 parallel algorithms are part of the core language and are supported by Microsoft Visual Studio starting from version 15.5. Additionally, Intel provides an open-source alternative implementation for C++ 11 parallel algorithms. On the other HAND, C++ 17 parallel algorithms are part of the C++ 17 standard and include three execution policies: sequential, unsequenced, and parallel. Intel's Parallel STL library supports C++ 17 parallel algorithms and provides efficient parallel execution for performance improvements.

Third-Party C++ Libraries for Parallel Computing

Apart from the aforementioned implementations, there are other third-party libraries available for parallel computing in C++. Some notable ones include Boost.Compute, Nvidia's Thrust library, and AMD's Bolt library. These libraries not only support CPU parallelism but also GPU parallelism, making them suitable for a wide range of applications. However, for the purpose of this article, we will focus on using Intel's open-source Parallel STL library to explore C++ 17 parallel algorithms.

C++ 17 Execution Policies: Explained

In C++ 17, execution policies were introduced as a mechanism to control the parallel execution of algorithms. Execution policies are passed as the first argument to the algorithms and serve as a hint to the compiler regarding the desired execution mode. There are four execution policies available in C++ 17: sequential, unsequenced, parallel, and parallel_unsequenced. The compiler has the final say in selecting the actual execution mode based on the policy provided. It is important to note that different implementations of parallel STL may have specific requirements or limitations on the types of iterators supported.

Pros and Cons of Intel's Parallel STL

Intel's Parallel STL library offers several advantages to developers. Firstly, it provides support for the C++ 20 execution::unset policy, which allows for more flexibility in parallel execution. The library also demonstrates strong scaling, meaning that it efficiently utilizes available resources to deliver improved performance. Furthermore, it is worth noting that Intel's Parallel STL is a header-only library, making it easy to integrate into existing projects. However, there are a few drawbacks to consider. The library only supports random access iterators, limiting its usability to vectors and arrays. Additionally, it relies on the Intel Threading Building Blocks (TBB) library, which may require additional configuration.

Tutorial: Benchmarks for Accelerated Parallel STL Library on StrongNet Clusters

To showcase the capabilities of the accelerated parallel STL library, we have prepared a tutorial that includes benchmarks for various algorithms. The benchmarks have been made available as a CMake build system on our official GitHub repository. In order to run the benchmarks, you will need to follow the provided instructions for installing Intel Parallel STL, TBB, and Google Benchmark libraries. These instructions cover both Graham and Cedar systems, allowing you to install all the necessary dependencies in your local home directory. Once the setup is complete, you can proceed to build and run the benchmarks using the provided commands. The tutorial includes benchmarks for algorithms such as sort, transform, reduce, and more. The results of these benchmarks can provide insights into the performance characteristics and scaling behavior of different parallel STL algorithms.

Conclusion

In conclusion, parallelizing the STL using Intel's Parallel STL library brings numerous benefits to C++ programmers. With its seamless integration, developers can easily leverage existing code that utilizes the STL and transform it into highly efficient parallel versions. By understanding the available execution policies and their impact, developers can effectively harness the power of parallel computing. Intel's implementation of parallel STL offers strong scaling and improved performance, making it a valuable tool for those seeking to maximize the potential of parallel algorithms. However, it's important to consider the limitations and dependencies that come with using Intel's Parallel STL library.