Program Listing for File simd_sse2.h

↰ Return to documentation for file (framework/simd/simd_sse2.h)

// SPDX-FileCopyrightText: 2026 The OpenSn Authors <https://open-sn.github.io/opensn/>
// SPDX-License-Identifier: MIT

#pragma once

#include <cstddef>
#include <cstdint>
#include <emmintrin.h>

// NOLINTBEGIN(portability-simd-intrinsics,cppcoreguidelines-pro-type-reinterpret-cast)
namespace opensn
{

struct SimdTraits
{
  using register_type = __m128d;
  using index_type = __m128i;
  static constexpr std::size_t size = 2;
  static constexpr std::size_t register_alignment = alignof(register_type);
  static constexpr std::size_t index_alignment = alignof(index_type);
};

} // namespace opensn

#include "framework/simd/simd_impl.h"

namespace opensn
{

inline SimdIndex::SimdIndex(const value_type* src)
  : value_(_mm_loadu_si128(reinterpret_cast<const __m128i*>(src)))
{
}

inline SimdIndex::register_type
SimdIndex::native() const
{
  return value_;
}

inline Simd::Simd() : value_(_mm_setzero_pd())
{
}

inline Simd::Simd(double value) : value_(_mm_set1_pd(value))
{
}

inline Simd::Simd(const double* src) : value_(_mm_loadu_pd(src))
{
}

inline void
Simd::LoadUnaligned(const double* src)
{
  value_ = _mm_loadu_pd(src);
}

inline void
Simd::StoreUnaligned(double* dst) const
{
  _mm_storeu_pd(dst, value_);
}

inline Simd
Simd::Gather(const double* src, const SimdIndex& index)
{
  alignas(SimdTraits::index_alignment) std::int64_t indices[size];
  alignas(SimdTraits::register_alignment) double values[size];
  _mm_storeu_si128(reinterpret_cast<__m128i*>(indices), index.value_);
  for (std::size_t i = 0; i < size; ++i)
    values[i] = src[indices[i]];
  return Simd(values);
}

inline void
Simd::Scatter(double* dst, const SimdIndex& index) const
{
  alignas(SimdTraits::index_alignment) std::int64_t indices[size];
  alignas(SimdTraits::register_alignment) double values[size];
  _mm_storeu_si128(reinterpret_cast<__m128i*>(indices), index.value_);
  _mm_storeu_pd(values, value_);
  for (std::size_t i = 0; i < size; ++i)
    dst[indices[i]] = values[i];
}

inline Simd::register_type
Simd::native() const
{
  return value_;
}

inline Simd&
Simd::operator+=(const Simd& other)
{
  value_ = _mm_add_pd(value_, other.value_);
  return *this;
}

inline Simd&
Simd::operator-=(const Simd& other)
{
  value_ = _mm_sub_pd(value_, other.value_);
  return *this;
}

inline Simd&
Simd::operator*=(const Simd& other)
{
  value_ = _mm_mul_pd(value_, other.value_);
  return *this;
}

inline Simd&
Simd::operator/=(const Simd& other)
{
  value_ = _mm_div_pd(value_, other.value_);
  return *this;
}

inline Simd
Simd::Fma(const Simd& a, const Simd& b, const Simd& c)
{
  Simd result;
  result.value_ = _mm_add_pd(_mm_mul_pd(a.value_, b.value_), c.value_);
  return result;
}

inline Simd
Simd::Fnma(const Simd& a, const Simd& b, const Simd& c)
{
  Simd result;
  result.value_ = _mm_sub_pd(c.value_, _mm_mul_pd(a.value_, b.value_));
  return result;
}

} // namespace opensn
// NOLINTEND(portability-simd-intrinsics,cppcoreguidelines-pro-type-reinterpret-cast)