VcShim.h

Go to the documentation of this file.

// Copyright 2020-2025 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#ifndef GPU_UTILS_VCSHIM_H
#define GPU_UTILS_VCSHIM_H
 
#ifndef GPUCA_NO_VC
 
#include <Vc/Vc>
 
#else
 
#include <algorithm>
#include <array>
#include <bitset>
#include <cstddef>
 
namespace Vc
{
 
constexpr struct VectorSpecialInitializerZero {
} Zero;
constexpr struct AlignedTag {
} Aligned;
 
template <typename T>
typename T::vector_type& internal_data(T& v)
{
  return v.mData;
}
 
template <typename T>
const typename T::vector_type& internal_data(const T& v)
{
  return v.mData;
}
 
namespace Common
{
 
template <typename V, typename M>
class WriteMaskVector
{
 private:
  const M& mMask;
  V& mVec;
 
 public:
  using value_type = typename V::value_type;
 
  WriteMaskVector(V& v, const M& m) : mMask(m), mVec(v) {}
 
  WriteMaskVector& operator++(int)
  {
    for (size_t i = 0; i < mVec.size(); i++)
      mVec[i] += value_type(mMask[i]);
    return *this;
  }
 
  WriteMaskVector& operator=(const value_type& v)
  {
    for (size_t i = 0; i < mVec.size(); i++) {
      if (mMask[i])
        mVec[i] = v;
    }
    return *this;
  }
};
 
inline void prefetchMid(const void*) {}
inline void prefetchFar(const void*) {}
inline void prefetchForOneRead(const void*) {}
 
} // namespace Common
 
template <typename T, size_t N>
class fixed_size_simd_mask
{
 private:
  std::bitset<N> mData;
 
 public:
  bool isNotEmpty() const { return mData.any(); }
 
  std::bitset<N>::reference operator[](size_t i) { return mData[i]; }
  bool operator[](size_t i) const { return mData[i]; }
 
  fixed_size_simd_mask operator!() const
  {
    auto o = *this;
    o.mData.flip();
    return o;
  }
};
 
template <typename T, size_t N>
class fixed_size_simd
{
 private:
  std::array<T, N> mData;
 
 public:
  using vector_type = std::array<T, N>;
  using value_type = T;
  using mask_type = fixed_size_simd_mask<T, N>;
 
  static constexpr size_t size() { return N; }
 
  fixed_size_simd() = default;
  explicit fixed_size_simd(VectorSpecialInitializerZero) { mData = {}; }
 
  template <typename U>
  fixed_size_simd(const fixed_size_simd<U, N>& w)
  {
    std::copy_n(internal_data(w).begin(), N, mData.begin());
  }
 
  fixed_size_simd(const T* d, AlignedTag) { std::copy_n(d, N, mData.begin()); }
 
  T& operator[](size_t i) { return mData[i]; }
  const T& operator[](size_t i) const { return mData[i]; }
 
  Common::WriteMaskVector<fixed_size_simd, mask_type> operator()(const mask_type& m) { return {*this, m}; }
 
  fixed_size_simd& operator=(const T& v)
  {
    for (auto& x : mData)
      x = v;
    return *this;
  }
 
  fixed_size_simd& operator+=(const T& v)
  {
    for (auto& x : mData)
      x += v;
    return *this;
  }
 
  fixed_size_simd& operator/=(const T& v)
  {
    for (auto& x : mData)
      x /= v;
    return *this;
  }
 
  fixed_size_simd operator/(const T& v) const
  {
    auto x = *this;
    return x /= v;
  }
 
  mask_type operator==(const T& v) const
  {
    mask_type m;
    for (size_t i = 0; i < N; i++)
      m[i] = mData[i] == v;
    return m;
  }
 
  mask_type operator!=(const T& v) const { return !(*this == v); }
 
  friend vector_type& internal_data<>(fixed_size_simd& x);
  friend const vector_type& internal_data<>(const fixed_size_simd& x);
};
 
template <typename V>
V max(const V& a, const V& b)
{
  V o;
  for (size_t i = 0; i < a.size(); i++)
    o[i] = std::max(a[i], b[i]);
  return o;
}
 
} // namespace Vc
 
#endif // ifndef GPUCA_NO_VC
 
#endif