Xsimd

https://github.com/xtensor-stack/xsimd
Admin
xsimd provides C++ wrappers for SIMD intrinsics, enabling unified manipulation of batches of numbers...
Tokens:3,912
Snippets:28
Trust Score:7.2
License:BSD-3-Clause
Update:1 year ago
Show doc for...
Tokens:
Raw
### Installing and Loading xsimd with Spack

Source: https://github.com/xtensor-stack/xsimd/blob/master/docs/source/installation.rst

Installs the xsimd library using the Spack package manager and then loads the installed package into the current environment.

```Shell
spack install xsimd
spack load xsimd
```

--------------------------------

### Install xsimd from Source

Source: https://github.com/xtensor-stack/xsimd/blob/master/README.md

Builds and installs the xsimd library from the configured source code using the `make install` command.

```bash
make install
```

--------------------------------

### Installing xsimd from Source with CMake (Unix)

Source: https://github.com/xtensor-stack/xsimd/blob/master/docs/source/installation.rst

Builds and installs the xsimd library from source on Unix-like platforms using CMake, specifying a custom installation prefix.

```CMake
mkdir build
cd build
cmake -DCMAKE_INSTALL_PREFIX=/path/to/prefix ..
make install
```

--------------------------------

### Installing xsimd from Source with CMake (Windows)

Source: https://github.com/xtensor-stack/xsimd/blob/master/docs/source/installation.rst

Builds and installs the xsimd library from source on Windows platforms using CMake and NMake Makefiles, specifying a custom installation prefix.

```CMake
mkdir build
cd build
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=/path/to/prefix ..
nmake
nmake install
```

--------------------------------

### Installing xsimd with Mamba/Conda

Source: https://github.com/xtensor-stack/xsimd/blob/master/docs/source/installation.rst

Installs the xsimd library using the mamba or conda package manager from the conda-forge channel.

```Shell
mamba install -c conda-forge xsimd
```

--------------------------------

### Build HTML Documentation (Bash)

Source: https://github.com/xtensor-stack/xsimd/blob/master/README.md

This bash command navigates to the documentation directory and runs the make command to build the HTML documentation for xsimd. This requires doxygen, sphinx, and breathe to be installed.

```Bash
cd docs
make html
```

--------------------------------

### Install xsimd with Spack

Source: https://github.com/xtensor-stack/xsimd/blob/master/README.md

Installs the xsimd library using the Spack package manager. Spack is a flexible package manager designed for scientific software.

```bash
spack install xsimd
```

--------------------------------

### Install Breathe with Pip (Bash)

Source: https://github.com/xtensor-stack/xsimd/blob/master/README.md

This bash command installs the breathe tool, which is used for building xsimd's HTML documentation, using the pip package installer.

```Bash
pip install breathe
```

--------------------------------

### Configure xsimd Source Build with CMake

Source: https://github.com/xtensor-stack/xsimd/blob/master/README.md

Configures the xsimd source code for building using CMake, specifying the installation prefix. Replace `your_install_prefix` with the desired installation path.

```bash
cmake -D CMAKE_INSTALL_PREFIX=your_install_prefix .
```

--------------------------------

### Load xsimd Spack Package

Source: https://github.com/xtensor-stack/xsimd/blob/master/README.md

Loads the installed xsimd package into the current environment using Spack, making it available for use.

```bash
spack load xsimd
```

--------------------------------

### Install xsimd with Mamba

Source: https://github.com/xtensor-stack/xsimd/blob/master/README.md

Installs the xsimd library using the Mamba package manager from the conda-forge channel. Mamba is a fast, parallel package manager compatible with Conda.

```bash
mamba install -c conda-forge xsimd
```

--------------------------------

### Install Breathe with Conda (Bash)

Source: https://github.com/xtensor-stack/xsimd/blob/master/README.md

This bash command installs the breathe tool using the conda package manager from the conda-forge channel. Breathe is required for building the xsimd HTML documentation.

```Bash
conda install -c conda-forge breathe
```

--------------------------------

### Install CMake with Conda (Bash)

Source: https://github.com/xtensor-stack/xsimd/blob/master/README.md

This bash command installs the cmake build tool using the conda package manager from the conda-forge channel. CMake is required for building the xsimd tests.

```Bash
conda install -c conda-forge cmake
```

--------------------------------

### Compute Mean with Explicit AVX2 Batch (C++)

Source: https://github.com/xtensor-stack/xsimd/blob/master/README.md

This C++ example demonstrates how to use xsimd to compute the mean of two sets of double values using the AVX2 instruction set explicitly. It initializes two xsimd batches with double values, performs element-wise addition and division, and prints the resulting batch.

```C++
#include <iostream>
#include "xsimd/xsimd.hpp"

namespace xs = xsimd;

int main(int argc, char* argv[])
{
    xs::batch<double, xs::avx2> a = {1.5, 2.5, 3.5, 4.5};
    xs::batch<double, xs::avx2> b = {2.5, 3.5, 4.5, 5.5};
    auto mean = (a + b) / 2;
    std::cout << mean << std::endl;
    return 0;
}
```

--------------------------------

### Build and Run Tests with CMake (Bash)

Source: https://github.com/xtensor-stack/xsimd/blob/master/README.md

These bash commands demonstrate the standard workflow for building and running xsimd tests using cmake. It creates a build directory, configures the project with tests enabled, and then builds and runs the test target.

```Bash
mkdir build
cd build
cmake ../ -DBUILD_TESTS=ON
make xtest
```

--------------------------------

### Build and Run Tests in Conda Env (Bash)

Source: https://github.com/xtensor-stack/xsimd/blob/master/README.md

These bash commands show how to build and run xsimd tests within a conda environment, typically used in continuous integration. It navigates to the test directory, creates and activates the environment, returns to the build directory, configures cmake, and runs the tests.

```Bash
cd test
conda env create -f ./test-environment.yml
source activate test-xsimd
cd ..
cmake . -DBUILD_TESTS=ON
make xtest
```

--------------------------------

### Using xsimd::dispatch for Runtime Architecture Selection

Source: https://github.com/xtensor-stack/xsimd/blob/master/docs/source/api/dispatching.rst

Demonstrates how to create a dispatching functor using `xsimd::dispatch`, specifying target architectures (AVX2, SSE2). The resulting functor can then be called with data, and xsimd will automatically select the appropriate architecture-specific implementation based on runtime CPU capabilities.

```C++
#include "sum.hpp"

// Create the dispatching function, specifying the architecture we want to
// target.
auto dispatched = xsimd::dispatch<xsimd::arch_list<xsimd::avx2, xsimd::sse2>>(sum{});

// Call the appropriate implementation based on runtime information.
float res = dispatched(data, 17);
```

--------------------------------

### Styling for Documentation Tables (CSS)

Source: https://github.com/xtensor-stack/xsimd/blob/master/docs/source/api/cast_index.rst

This CSS snippet provides styling rules for tables and code blocks within the documentation generated by Sphinx/reStructuredText, specifically targeting tables with the 'docutils' class to ensure fixed layout and proper appearance of inline code.

```css
.rst-content table.docutils {
    width: 100%;
    table-layout: fixed;
}

table.docutils .line-block {
    margin-left: 0;
    margin-bottom: 0;
}

table.docutils code.literal {
    color: initial;
}

code.docutils {
    background: initial;
}
```

--------------------------------

### AVX2 Optimized Sum Implementation (sum_avx2.cpp)

Source: https://github.com/xtensor-stack/xsimd/blob/master/docs/source/api/dispatching.rst

Provides an explicit template specialization of the `sum` functor's call operator for the AVX2 architecture. This implementation uses xsimd's batch processing capabilities to perform the sum operation efficiently on data using AVX2 instructions. This file must be compiled with appropriate AVX2 flags.

```C++
#include "sum.hpp"
#include <xsimd/xsimd.hpp>

// Explicit specialization for AVX2
template <>
float sum::operator()<xsimd::avx2, float>(xsimd::avx2, const std::vector<float>& data, size_t size) const {
    using batch_type = xsimd::batch<float, xsimd::avx2>;
    size_t vector_size = batch_type::size;
    size_t nb_batches = size / vector_size;
    batch_type total_batch(0.0f);

    for (size_t i = 0; i < nb_batches; ++i) {
        total_batch += batch_type::load_unaligned(&data[i * vector_size]);
    }

    float total = xsimd::hadd(total_batch);

    // Handle remaining elements
    for (size_t i = nb_batches * vector_size; i < size; ++i) {
        total += data[i];
    }

    return total;
}
```

--------------------------------

### SSE2 Optimized Sum Implementation (sum_sse2.cpp)

Source: https://github.com/xtensor-stack/xsimd/blob/master/docs/source/api/dispatching.rst

Provides an explicit template specialization of the `sum` functor's call operator for the SSE2 architecture. This implementation uses xsimd's batch processing capabilities to perform the sum operation efficiently on data using SSE2 instructions. This file must be compiled with appropriate SSE2 flags.

```C++
#include "sum.hpp"
#include <xsimd/xsimd.hpp>

// Explicit specialization for SSE2
template <>
float sum::operator()<xsimd::sse2, float>(xsimd::sse2, const std::vector<float>& data, size_t size) const {
    using batch_type = xsimd::batch<float, xsimd::sse2>;
    size_t vector_size = batch_type::size;
    size_t nb_batches = size / vector_size;
    batch_type total_batch(0.0f);

    for (size_t i = 0; i < nb_batches; ++i) {
        total_batch += batch_type::load_unaligned(&data[i * vector_size]);
    }

    float total = xsimd::hadd(total_batch);

    // Handle remaining elements
    for (size_t i = nb_batches * vector_size; i < size; ++i) {
        total += data[i];
    }

    return total;
}
```

--------------------------------

### Generic Sum Functor Definition (sum.hpp)

Source: https://github.com/xtensor-stack/xsimd/blob/master/docs/source/api/dispatching.rst

Defines a generic `sum` functor template. This header provides the architecture-agnostic interface that `xsimd::dispatch` uses. It includes a basic fallback implementation that can be specialized for specific architectures in separate compilation units.

```C++
#ifndef SUM_HPP
#define SUM_HPP

#include <vector>
#include <numeric>
#include <xsimd/xsimd.hpp>

struct sum {
    template <class Arch, class T>
    T operator()(Arch, const std::vector<T>& data, size_t size) const {
        // Generic fallback or base implementation
        T total = 0;
        for (size_t i = 0; i < size; ++i) {
            total += data[i];
        }
        return total;
    }
};

#endif
```

--------------------------------

### Vectorizing Mean with Alignment Tag Dispatching - C++

Source: https://github.com/xtensor-stack/xsimd/blob/master/docs/source/vectorized_code.rst

This C++ function template vectorizes the mean computation using `xsimd::batch` and an alignment tag (`xsimd::aligned_mode` or `xsimd::unaligned_mode`). It uses `xsimd::load` and `xsimd::store`, which are overloaded to handle the specified alignment mode.

```C++
#include <xsimd/xsimd.hpp>
#include <vector>

template <class T, class A, class Tag>
void mean_tag_dispatch(const std::vector<T, A>& a, const std::vector<T, A>& b, std::vector<T, A>& res, Tag tag) {
    using batch_type = xsimd::batch<T>; // xsimd picks best architecture
    size_t size = a.size();
    size_t vector_size = batch_type::size;
    size_t nb_batches = size / vector_size;

    for (size_t i = 0; i < nb_batches; ++i) {
        size_t offset = i * vector_size;
        batch_type batch_a = xsimd::load(&a[offset], tag);
        batch_type batch_b = xsimd::load(&b[offset], tag);
        batch_type batch_res = (batch_a + batch_b) / 2.0;
        xsimd::store(&res[offset], batch_res, tag);
    }

    // Handle remaining elements
    for (size_t i = nb_batches * vector_size; i < size; ++i) {
        res[i] = (a[i] + b[i]) / 2.0;
    }
}
```

--------------------------------

### Calling Tag-Dispatched Vectorized Mean - C++

Source: https://github.com/xtensor-stack/xsimd/blob/master/docs/source/vectorized_code.rst

This C++ code snippet demonstrates how to call the `mean_tag_dispatch` function template, passing the vectors and an alignment tag obtained via a hypothetical `get_alignment_tag` meta-function based on the vector type.

```C++
mean(a, b, res, get_alignment_tag<decltype(a)>());
```

--------------------------------

### Vectorizing Mean with Architecture and Tag Dispatching - C++

Source: https://github.com/xtensor-stack/xsimd/blob/master/docs/source/vectorized_code.rst

This C++ code defines a function object (`mean` struct) with a templated `operator()` that takes an architecture type (`Arch`) and an alignment tag (`Tag`). This allows the same code to be used with different architectures and alignment modes, facilitating runtime dispatching.

```C++
#include <xsimd/xsimd.hpp>
#include <vector>

struct mean {
    template <class Arch, class T, class A, class Tag>
    void operator()(Arch, const std::vector<T, A>& a, const std::vector<T, A>& b, std::vector<T, A>& res, Tag tag) const {
        using batch_type = xsimd::batch<T, Arch>; // Use specified architecture
        size_t size = a.size();
        size_t vector_size = batch_type::size;
        size_t nb_batches = size / vector_size;

        for (size_t i = 0; i < nb_batches; ++i) {
            size_t offset = i * vector_size;
            batch_type batch_a = xsimd::load(&a[offset], tag);
            batch_type batch_b = xsimd::load(&b[offset], tag);
            batch_type batch_res = (batch_a + batch_b) / 2.0;
            xsimd::store(&res[offset], batch_res, tag);
        }

        // Handle remaining elements
        for (size_t i = nb_batches * vector_size; i < size; ++i) {
            res[i] = (a[i] + b[i]) / 2.0;
        }
    }
};
```

--------------------------------

### Vectorizing Mean with Explicit AVX (Unaligned) - C++

Source: https://github.com/xtensor-stack/xsimd/blob/master/docs/source/vectorized_code.rst

This C++ function vectorizes the mean computation using `xsimd::batch<double, xsimd::avx>`. It loads data from input vectors `a` and `b` using `load_unaligned`, performs the mean operation on batches, and stores the results into `res` using `store_unaligned`.

```C++
#include <xsimd/xsimd.hpp>
#include <vector>

void mean_avx_unaligned(const std::vector<double>& a, const std::vector<double>& b, std::vector<double>& res) {
    using batch_type = xsimd::batch<double, xsimd::avx>;
    size_t size = a.size();
    size_t vector_size = batch_type::size;
    size_t nb_batches = size / vector_size;

    for (size_t i = 0; i < nb_batches; ++i) {
        size_t offset = i * vector_size;
        batch_type batch_a = xsimd::load_unaligned(&a[offset]);
        batch_type batch_b = xsimd::load_unaligned(&b[offset]);
        batch_type batch_res = (batch_a + batch_b) / 2.0;
        xsimd::store_unaligned(&res[offset], batch_res);
    }

    // Handle remaining elements
    for (size_t i = nb_batches * vector_size; i < size; ++i) {
        res[i] = (a[i] + b[i]) / 2.0;
    }
}
```

--------------------------------

### Vectorizing Mean with Explicit AVX (Aligned) - C++

Source: https://github.com/xtensor-stack/xsimd/blob/master/docs/source/vectorized_code.rst

This C++ function vectorizes the mean computation using `xsimd::batch<double, xsimd::avx>` and assumes aligned memory. It uses `xsimd::aligned_allocator` for the vectors and loads/stores data using `load_aligned` and `store_aligned`.

```C++
#include <xsimd/xsimd.hpp>
#include <vector>

// Assuming vectors a, b, res use xsimd::aligned_allocator
void mean_avx_aligned(const std::vector<double, xsimd::aligned_allocator<double>>& a,
                      const std::vector<double, xsimd::aligned_allocator<double>>& b,
                      std::vector<double, xsimd::aligned_allocator<double>>& res) {
    using batch_type = xsimd::batch<double, xsimd::avx>;
    size_t size = a.size();
    size_t vector_size = batch_type::size;
    size_t nb_batches = size / vector_size;

    for (size_t i = 0; i < nb_batches; ++i) {
        size_t offset = i * vector_size;
        batch_type batch_a = xsimd::load_aligned(&a[offset]);
        batch_type batch_b = xsimd::load_aligned(&b[offset]);
        batch_type batch_res = (batch_a + batch_b) / 2.0;
        xsimd::store_aligned(&res[offset], batch_res);
    }

    // Handle remaining elements
    for (size_t i = nb_batches * vector_size; i < size; ++i) {
        res[i] = (a[i] + b[i]) / 2.0;
    }
}
```

--------------------------------

### Compute Mean with Auto-Detected SIMD (C++)

Source: https://github.com/xtensor-stack/xsimd/blob/master/README.md

This C++ function computes the element-wise mean of two vectors of doubles using xsimd's auto-detection of the most performant instruction set. It processes the vectors in batches using aligned loads and stores, falling back to scalar operations for any remaining elements.

```C++
#include <cstddef>
#include <vector>
#include "xsimd/xsimd.hpp"

namespace xs = xsimd;
using vector_type = std::vector<double, xsimd::aligned_allocator<double>>;

void mean(const vector_type& a, const vector_type& b, vector_type& res)
{
    std::size_t size = a.size();
    constexpr std::size_t simd_size = xsimd::simd_type<double>::size;
    std::size_t vec_size = size - size % simd_size;

    for(std::size_t i = 0; i < vec_size; i += simd_size)
    {
        auto ba = xs::load_aligned(&a[i]);
        auto bb = xs::load_aligned(&b[i]);
        auto bres = (ba + bb) / 2.;
        bres.store_aligned(&res[i]);
    }
    for(std::size_t i = vec_size; i < size; ++i)
    {
        res[i] = (a[i] + b[i]) / 2.;
    }
}
```

--------------------------------

### Computing Mean of Vectors (Non-Vectorized) - C++

Source: https://github.com/xtensor-stack/xsimd/blob/master/docs/source/vectorized_code.rst

This C++ function computes the element-wise mean of two input vectors `a` and `b`, storing the result in vector `res`. It iterates through the vectors element by element without using SIMD instructions.

```C++
void mean(const std::vector<double>& a, const std::vector<double>& b, std::vector<double>& res) {
    for (size_t i = 0; i < a.size(); ++i) {
        res[i] = (a[i] + b[i]) / 2.0;
    }
}
```
Tokens:
Raw