SIMDHelpers.h

/*
  ==============================================================================
    DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
    Copyright 2022- by sonible GmbH.
 
    This file is part of VCTR - Versatile Container Templates Reconceptualized.
 
    VCTR is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License version 3
    only, as published by the Free Software Foundation.
 
    VCTR is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License version 3 for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    version 3 along with VCTR.  If not, see <https://www.gnu.org/licenses/>.
  ==============================================================================
*/
 
namespace vctr::detail
{
template <size_t value>
requires (is::powerOfTwoInt<value>)
constexpr size_t previousMultipleOf (size_t numElements)
{
    constexpr auto numMaskBits = std::bit_width (value) - 1;
    constexpr auto allBitsOne = size_t (-1);
    constexpr auto mask = allBitsOne << numMaskBits;
 
    return numElements & mask;
}
 
template <size_t value>
requires (is::powerOfTwoInt<value>)
constexpr size_t nextMultipleOf (size_t numElements)
{
    return size_t ((int64_t (numElements) + int64_t (value) - 1) & -int64_t (value));
}
 
} // namespace vctr::detail
 
namespace vctr
{
 
#if (! VCTR_X64)
// These are defined in immintrin.h – defining them here for non x86 builds
// to be able to assign the CompareOp enum cross-platform
// NOLINTBEGIN (*-reserved-identifier)
constexpr auto _CMP_LT_OQ = 0;
constexpr auto _CMP_LE_OQ = 1;
constexpr auto _CMP_GT_OQ = 2;
constexpr auto _CMP_GE_OQ = 3;
constexpr auto _CMP_EQ_OQ = 4;
constexpr auto _CMP_NEQ_OQ = 5;
// NOLINTEND (*-reserved-identifier)
#endif
 
enum class CompareOp : int
{
    less = _CMP_LT_OQ,           // <
    lessOrEqual = _CMP_LE_OQ,    // <=
    greater = _CMP_GT_OQ,        // >
    greaterOrEqual = _CMP_GE_OQ, // >=
    equal = _CMP_EQ_OQ,          // ==
    notEqual = _CMP_NEQ_OQ       // !=
};
 
template <uintptr_t requiredAlignment = Config::maxSIMDRegisterSize>
inline constexpr bool isPtrAligned (const void* ptr)
{
    // SIMD alignment is not meaningful in case of constant evaluation
    if (std::is_constant_evaluated())
        return false;
 
    return reinterpret_cast<std::uintptr_t> (ptr) % requiredAlignment == 0;
}
 
template <class StorageType>
struct StorageInfo
{
    // The default implementation is empty and should never be used
};
 
template <has::sizeAndData StorageType>
struct StorageInfo<StorageType>
{
    constexpr StorageInfo()
        : dataIsSIMDAligned (false),
          hasSIMDExtendedStorage (false)
    {}
 
    template <is::storageInfo OtherStorageInfoType>
    constexpr StorageInfo (const OtherStorageInfoType& other)
        : dataIsSIMDAligned (other.dataIsSIMDAligned),
          hasSIMDExtendedStorage (other.hasSIMDExtendedStorage)
    {}
 
    template <class T>
    constexpr StorageInfo init (const T* ptr, size_t s)
    {
        dataIsSIMDAligned = isPtrAligned (ptr);
        hasSIMDExtendedStorage = (s * sizeof (T)) % Config::maxSIMDRegisterSize == 0;
        return *this;
    }
 
    static constexpr size_t memberAlignment = alignof (StorageType);
 
    bool dataIsSIMDAligned;
 
    bool hasSIMDExtendedStorage;
};
 
template <class ElementType, size_t alignmentInBytes>
struct StorageInfo<std::vector<ElementType, AlignedAllocator<ElementType, alignmentInBytes>>>
{
    constexpr StorageInfo init (const void*, size_t) { return *this; }
 
    static constexpr size_t memberAlignment = alignof (std::vector<ElementType, AlignedAllocator<ElementType, alignmentInBytes>>);
 
    static constexpr bool dataIsSIMDAligned = alignmentInBytes == Config::maxSIMDRegisterSize;
 
    static constexpr bool hasSIMDExtendedStorage = true;
};
 
template <class ElementType, size_t size>
struct StorageInfo<std::array<ElementType, size>>
{
    constexpr StorageInfo init (const void*, size_t) { return *this; }
 
    static constexpr size_t memberAlignment = Config::alignedArray ? Config::maxSIMDRegisterSize : alignof (std::array<ElementType, size>);
 
    static constexpr bool dataIsSIMDAligned = Config::alignedArray;
 
    static constexpr bool hasSIMDExtendedStorage = (size * sizeof (ElementType)) % Config::maxSIMDRegisterSize == 0;
};
 
template <class Allocator>
struct StorageInfo<detail::VectorBoolWorkaround<Allocator>>
{
    constexpr StorageInfo init (const void*, size_t) { return *this; }
 
    static constexpr size_t memberAlignment = alignof (detail::VectorBoolWorkaround<Allocator>);
 
    static constexpr bool dataIsSIMDAligned = false;
 
    static constexpr bool hasSIMDExtendedStorage = false;
};
 
template <bool isDataSIMDAligned, bool isStorageSIMDExtended, size_t customMemberAlignment>
struct StaticStorageInfo
{
    static constexpr bool dataIsSIMDAligned = isDataSIMDAligned;
    static constexpr bool hasSIMDExtendedStorage = isStorageSIMDExtended;
    static constexpr size_t memberAlignment = customMemberAlignment;
};
 
template <size_t alignment, class WrappedInfo>
struct StorageInfoWithMemberAlignment : WrappedInfo
{
    constexpr StorageInfoWithMemberAlignment() = default;
 
    constexpr StorageInfoWithMemberAlignment (const WrappedInfo& i) : WrappedInfo (i) {}
 
    static constexpr size_t memberAlignment = alignment;
};
 
namespace detail
{
 
template <bool, bool>
struct ConstexprStorageInfoChecker
{
};
} // namespace detail
 
namespace is
{
template <class T>
concept constexprStorageInfo = requires (const T&) { detail::ConstexprStorageInfoChecker<T::dataIsSIMDAligned, T::hasSIMDExtendedStorage>(); };
}
 
template <class First, class... Others>
struct CombinedStorageInfo
{
    CombinedStorageInfo (const First& first, const Others&... others)
        : dataIsSIMDAligned (first.dataIsSIMDAligned && (others.dataIsSIMDAligned && ...)),
          hasSIMDExtendedStorage (first.hasSIMDExtendedStorage && (others.hasSIMDExtendedStorage && ...))
    {}
 
    bool dataIsSIMDAligned;
 
    bool hasSIMDExtendedStorage;
};
 
template <is::constexprStorageInfo First, is::constexprStorageInfo... Others>
struct CombinedStorageInfo<First, Others...>
{
    constexpr CombinedStorageInfo (const First&, const Others&...) {}
 
    static constexpr bool dataIsSIMDAligned = First::dataIsSIMDAligned && (Others::dataIsSIMDAligned && ...);
 
    static constexpr bool hasSIMDExtendedStorage = First::hasSIMDExtendedStorage && (Others::hasSIMDExtendedStorage && ...);
};
 
} // namespace vctr