permuted_view_constexpr.h

Go to the documentation of this file.

#ifndef FUSED_PERMUTED_VIEW_CONSTEXPR_H
#define FUSED_PERMUTED_VIEW_CONSTEXPR_H
 
#include "config.h"
#include "fused/BaseExpr.h"
#include "fused/layouts/strided_layout_constexpr.h"
#include "helper_traits.h"
 
template <typename Tensor, my_size_t... Perm>
class PermutedViewConstExpr : public BaseExpr<PermutedViewConstExpr<Tensor, Perm...>>
{
    // Static assertions to validate the permutation pack at compile time
    static_assert(sizeof...(Perm) == Tensor::NumDims,
                  "Permutation pack must match tensor's number of dimensions");
 
    static_assert(all_unique<Perm...>(),
                  "Permutation indices must be unique");
 
    static_assert(max_value<Perm...>() < Tensor::NumDims,
                  "Max value of permutation pack is greater than the tensor's number of dimensions");
 
    static_assert(min_value<Perm...>() == 0,
                  "Min value of permutation pack is not equal to 0");
 
public:
    using value_type = typename Tensor::value_type;
    using PadPolicy = typename Tensor::AccessPolicy::PadPolicy;
    using Layout = StridedLayoutConstExpr<PadPolicy, Perm...>;
 
    static constexpr my_size_t NumDims = Layout::NumDims;
    static constexpr my_size_t Dim[] = {Tensor::Dim[Perm]...};
    static constexpr my_size_t TotalSize = Tensor::TotalSize;
 
    explicit PermutedViewConstExpr(const Tensor &t) noexcept
        : t_(t) {}
 
    // Views are non-copyable, non-movable — they're lightweight references.
    // delete copy constructor and copy assignment to avoid accidental copies
    PermutedViewConstExpr(const PermutedViewConstExpr &) = delete;
    PermutedViewConstExpr &operator=(const PermutedViewConstExpr &) = delete;
 
    // delete move constructor and move assignment to avoid accidental moves
    PermutedViewConstExpr(PermutedViewConstExpr &&) = delete;
    PermutedViewConstExpr &operator=(PermutedViewConstExpr &&) = delete;
 
    template <typename Output>
    bool may_alias(const Output &output) const noexcept
    {
        return t_.may_alias(output); // recurse to underlying tensor
    }
 
    // Const version of the access operator, because this is a view
    template <typename... Indices>
        requires(sizeof...(Indices) == NumDims)
    FORCE_INLINE const value_type &operator()(Indices... indices) const TESSERACT_CONDITIONAL_NOEXCEPT
    {
        my_size_t idxArray[] = {static_cast<my_size_t>(indices)...};
        return t_.data_.data()[Layout::logical_coords_to_physical_flat(idxArray)];
    }
 
    // Const version of the access operator with array of indices, because this is a view
    FORCE_INLINE const value_type &operator()(my_size_t (&indices)[NumDims]) const TESSERACT_CONDITIONAL_NOEXCEPT
    {
        return t_.data_.data()[Layout::logical_coords_to_physical_flat(indices)];
    }
 
    FORCE_INLINE const value_type &operator()(const my_size_t *indices) const TESSERACT_CONDITIONAL_NOEXCEPT
    {
        return t_.data_.data()[Layout::logical_coords_to_physical_flat(indices)];
    }
 
    // ========================================================================
    // PermutedViewConstExpr::evalu — logical flat, K::gather
    // ========================================================================
    // Only used by permuted path. Each logical flat index is remapped
    // through the permuted layout to a source physical offset.
    // Consecutive logical flats map to non-contiguous source positions → gather.
 
    template <typename T, my_size_t Bits, typename Arch>
    FORCE_INLINE typename Microkernel<T, Bits, Arch>::VecType evalu(my_size_t logical_flat) const noexcept
    {
        using K = Microkernel<T, Bits, Arch>;
        constexpr my_size_t width = K::simdWidth;
 
        my_size_t idxList[width];
        for (my_size_t i = 0; i < width; ++i)
            idxList[i] = Layout::logical_flat_to_physical_flat(logical_flat + i);
 
        return K::gather(t_.data_.data(), idxList);
    }
 
    template <typename T, my_size_t Bits, typename Arch>
    FORCE_INLINE typename Microkernel<T, Bits, Arch>::VecType logical_evalu(my_size_t logical_flat) const noexcept
    {
        // evalu already expects logical flat for permuted views
        return evalu<T, Bits, Arch>(logical_flat);
    }
 
    FORCE_INLINE static constexpr my_size_t getDim(my_size_t i) TESSERACT_CONDITIONAL_NOEXCEPT
    {
        return Layout::logical_dim(i);
    }
 
    FORCE_INLINE static constexpr my_size_t getStride(my_size_t i) TESSERACT_CONDITIONAL_NOEXCEPT
    {
        return Layout::stride(i);
    }
 
    FORCE_INLINE static constexpr my_size_t getNumDims() noexcept { return NumDims; }
 
    FORCE_INLINE static constexpr my_size_t getTotalSize() noexcept { return TotalSize; }
 
    // print layout info
    void printLayoutInfo() const
    {
        MyErrorHandler::log("PermutedView Layout Info:", ErrorLevel::Info);
        MyErrorHandler::log("Number of Dimensions: " + std::to_string(NumDims), ErrorLevel::Info);
        MyErrorHandler::log("Shape: " + getShape(), ErrorLevel::Info);
        MyErrorHandler::log("Strides: ", ErrorLevel::Info);
        for (my_size_t i = 0; i < NumDims; ++i)
            MyErrorHandler::log(std::to_string(getStride(i)) + " ", ErrorLevel::Info);
        MyErrorHandler::log("\n", ErrorLevel::Info);
    }
 
    // Inverse permutation — restores the base tensor
    FORCE_INLINE const Tensor &transpose() const noexcept { return t_; }
 
    // Utility function to retrieve the shape of the tensor as (1,5,6) for a 3D tensor use the getNumDims
    std::string getShape() const
    {
        std::string shape = "(";
        for (my_size_t i = 0; i < NumDims; ++i)
        {
            shape += std::to_string(getDim(i));
            if (i < NumDims - 1)
                shape += ",";
        }
        shape += ")";
        return shape;
    }
 
    FORCE_INLINE constexpr const value_type *data() const noexcept { return t_.data_.data(); }
    FORCE_INLINE constexpr value_type *data() noexcept { return t_.data_.data(); }
 
private:
    const Tensor &t_;
 
    // FORCE_INLINE constexpr const value_type *data() const noexcept { return t_.data_.data(); }
 
    // template <typename, my_size_t, typename>
    // friend struct KernelOps;
};
 
#endif // FUSED_PERMUTED_VIEW_CONSTEXPR_H