simd_padding_policy.h

Go to the documentation of this file.

#pragma once
 
#include "config.h"                              // for my_size_t, BITS, DefaultArch
#include "fused/microkernels/microkernel_base.h" // for Microkernel, DATA_ALIGNAS
#include "containers/array.h"                    // for Array
 
template <typename T, my_size_t SIMDWidth, my_size_t... Dims>
struct SimdPaddingPolicyBase
{
    // ========================================================================
    // COMPILE-TIME VALIDATION
    // ========================================================================
 
    static_assert(sizeof...(Dims) > 0, "SimdPaddingPolicy: At least one dimension is required");
 
    // ========================================================================
    // SIMD CONFIGURATION FROM MICROKERNEL
    // ========================================================================
 
    static constexpr my_size_t SimdWidth = SIMDWidth;
 
    static_assert(SimdWidth >= 1, "SimdPaddingPolicy: SimdWidth must be at least 1");
 
    // ========================================================================
    // COMPILE-TIME DIMENSION ANALYSIS
    // ========================================================================
 
    static constexpr my_size_t NumDims = sizeof...(Dims);
 
    static constexpr Array<my_size_t, NumDims> computeLogicalDims()
    {
        return Array<my_size_t, NumDims>{Dims...};
    }
 
    static constexpr Array<my_size_t, NumDims> LogicalDims = computeLogicalDims();
 
    // ========================================================================
    // PADDING COMPUTATION
    // ========================================================================
 
    static constexpr my_size_t pad(my_size_t n)
    {
        return ((n + SimdWidth - 1) / SimdWidth) * SimdWidth;
    }
 
    static constexpr my_size_t LastDim = LogicalDims[NumDims - 1];
 
    static constexpr my_size_t PaddedLastDim = pad(LastDim);
 
    static constexpr my_size_t LogicalSize = (Dims * ...);
 
    static constexpr my_size_t computePhysicalSize()
    {
        my_size_t size = 1;
        for (my_size_t i = 0; i < NumDims - 1; ++i)
            size *= LogicalDims[i];
        return size * PaddedLastDim;
    }
 
    static constexpr my_size_t PhysicalSize = computePhysicalSize();
 
    // ========================================================================
    // PHYSICAL DIMENSIONS (for StridedLayout)
    // ========================================================================
 
    static constexpr Array<my_size_t, NumDims> computePhysicalDims()
    {
        Array<my_size_t, NumDims> result{};
        for (my_size_t i = 0; i < NumDims - 1; ++i)
            result[i] = LogicalDims[i];
        result[NumDims - 1] = PaddedLastDim;
        return result;
    }
 
    static constexpr Array<my_size_t, NumDims> PhysicalDims = computePhysicalDims();
};
 
// Production alias - gets SimdWidth from Microkernel
template <typename T, my_size_t... Dims>
using SimdPaddingPolicy = SimdPaddingPolicyBase<T, Microkernel<T, BITS, DefaultArch>::simdWidth, Dims...>;