Awesome Open Source
Awesome Open Source

Vc is now in maintenance mode and no longer actively developed. However, we continue to review pull requests with bugfixes from the community.

You may be interested in switching to std-simd. GCC 11 includes an experimental version of std::simd as part of libstdc++, which also works with clang. Features present in Vc 1.4 and not present in std-simd will eventually turn into Vc 2.0,which then depends on std-simd.

Vc: portable, zero-overhead C++ types for explicitly data-parallel programming

Recent generations of CPUs, and GPUs in particular, require data-parallel codes for full efficiency. Data parallelism requires that the same sequence of operations is applied to different input data. CPUs and GPUs can thus reduce the necessary hardware for instruction decoding and scheduling in favor of more arithmetic and logic units, which execute the same instructions synchronously. On CPU architectures this is implemented via SIMD registers and instructions. A single SIMD register can store N values and a single SIMD instruction can execute N operations on those values. On GPU architectures N threads run in perfect sync, fed by a single instruction decoder/scheduler. Each thread has local memory and a given index to calculate the offsets in memory for loads and stores.

Current C++ compilers can do automatic transformation of scalar codes to SIMD instructions (auto-vectorization). However, the compiler must reconstruct an intrinsic property of the algorithm that was lost when the developer wrote a purely scalar implementation in C++. Consequently, C++ compilers cannot vectorize any given code to its most efficient data-parallel variant. Especially larger data-parallel loops, spanning over multiple functions or even translation units, will often not be transformed into efficient SIMD code.

The Vc library provides the missing link. Its types enable explicitly stating data-parallel operations on multiple values. The parallelism is therefore added via the type system. Competing approaches state the parallelism via new control structures and consequently new semantics inside the body of these control structures.

Vc is a free software library to ease explicit vectorization of C++ code. It has an intuitive API and provides portability between different compilers and compiler versions as well as portability between different vector instruction sets. Thus an application written with Vc can be compiled for:

  • AVX and AVX2
  • SSE2 up to SSE4.2 or SSE4a
  • Scalar
  • AVX-512 (Vc 2 development)
  • NEON (in development)
  • NVIDIA GPUs / CUDA (research)

After Intel dropped MIC support with ICC 18, Vc 1.4 also removed support for it.

Examples

Usage on Compiler Explorer

Scalar Product

Let's start from the code for calculating a 3D scalar product using builtin floats:

using Vec3D = std::array<float, 3>;
float scalar_product(Vec3D a, Vec3D b) {
  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
}

Using Vc, we can easily vectorize the code using the float_v type:

using Vc::float_v
using Vec3D = std::array<float_v, 3>;
float_v scalar_product(Vec3D a, Vec3D b) {
  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
}

The above will scale to 1, 4, 8, 16, etc. scalar products calculated in parallel, depending on the target hardware's capabilities.

For comparison, the same vectorization using Intel SSE intrinsics is more verbose and uses prefix notation (i.e. function calls):

using Vec3D = std::array<__m128, 3>;
__m128 scalar_product(Vec3D a, Vec3D b) {
  return _mm_add_ps(_mm_add_ps(_mm_mul_ps(a[0], b[0]), _mm_mul_ps(a[1], b[1])),
                    _mm_mul_ps(a[2], b[2]));
}

The above will neither scale to AVX, AVX-512, etc. nor is it portable to other SIMD ISAs.

Build Requirements

cmake >= 3.0

C++11 Compiler:

  • GCC >= 4.8.1
  • clang >= 3.4
  • ICC >= 18.0.5
  • Visual Studio 2019 (64-bit target)

Building and Installing Vc

  • Clone Vc and initialize Vc's git submodules:
git clone https://github.com/VcDevel/Vc.git
cd Vc
git submodule update --init
  • Create a build directory:
$ mkdir build
$ cd build
  • Configure with cmake and add relevant options:
$ cmake ..

Optionally, specify an installation directory:

$ cmake -DCMAKE_INSTALL_PREFIX=/opt/Vc ..

Optionally, include building the unit tests:

$ cmake -DBUILD_TESTING=ON ..

On Windows, if you have multiple versions of Visual Studio installed, you can select one:

$ cmake -G "Visual Studio 16 2019" ..

See cmake --help for a list of possible generators.

  • Build and install:
$ cmake --build . -j 16
$ cmake --install . # may require permissions

On Windows, you can also open Vc.sln in Visual Studio and build/install from the IDE.

Documentation

The documentation is generated via doxygen. You can build the documentation by running doxygen in the doc subdirectory. Alternatively, you can find nightly builds of the documentation at:

Publications

Work on integrating the functionality of Vc in the C++ standard library.

License

Vc is released under the terms of the 3-clause BSD license.



Alternative Project Comparisons
Related Awesome Lists
Top Programming Languages
Top Projects

Get A Weekly Email With Trending Projects For These Topics
No Spam. Unsubscribe easily at any time.
C Plus Plus (236,456
Cpp (236,448
Cpp11 (236,439
Cpp17 (236,439
Cpp14 (236,438
Parallel (7,126
Sse (1,404
Simd (1,020
Neon (928
Avx (868
Avx2 (868
Parallelism (816
Parallel Computing (708
Vectorization (341
Simd Instructions (104
Avx512 (101
Simd Programming (19
Data Parallel (7
Simd Vector (4