/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/ck/utility/container_element_picker.hpp Source File

/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/ck/utility/container_element_picker.hpp Source File#

Composable Kernel: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/ck/utility/container_element_picker.hpp Source File

Go to the documentation of this file.

 // SPDX-License-Identifier: MIT
 // Copyright (c) 2018-2023, Advanced Micro Devices, Inc. All rights reserved.
  
 #ifndef CK_CONTAINER_ELEMENT_PICKER_HPP
 #define CK_CONTAINER_ELEMENT_PICKER_HPP
  
 #include "functional2.hpp"
 #include "sequence.hpp"
  
 namespace ck {
  
 // Arr: Array or StaticallyIndexedArray
 // Picks: Sequence<...>
 template <typename Arr, typename Picks>
 struct ContainerElementPicker
 {
     using type = ContainerElementPicker;
 #if 0
     using data_type = typename Arr::data_type;
 #endif
  
     __host__ __device__ constexpr ContainerElementPicker() = delete;
  
     __host__ __device__ constexpr ContainerElementPicker(Arr& array) : mArray{array}
     {
         constexpr index_t imax =
             reduce_on_sequence(Picks{}, math::maximize<index_t>{}, Number<0>{});
  
         static_assert(imax < Arr::Size(), "wrong! exceeding # array element");
     }
  
     __host__ __device__ static constexpr auto Size() { return Picks::Size(); }
  
     template <index_t I>
     __host__ __device__ constexpr const auto& At(Number<I> i) const
     {
         static_assert(I < Size(), "wrong!");
  
         constexpr auto IP = Picks{}[i];
         return mArray[IP];
     }
  
     template <index_t I>
     __host__ __device__ constexpr auto& At(Number<I> i)
     {
         static_assert(I < Size(), "wrong!");
  
         constexpr auto IP = Picks{}[i];
         return mArray(IP);
     }
  
     template <index_t I>
     __host__ __device__ constexpr const auto& operator[](Number<I> i) const
     {
         return At(i);
     }
  
     template <index_t I>
     __host__ __device__ constexpr auto& operator()(Number<I> i)
     {
         return At(i);
     }
  
     template <typename T>
     __host__ __device__ constexpr auto operator=(const T& a)
     {
         static_assert(T::Size() == Size(), "wrong! size not the same");
  
         static_for<0, Size(), 1>{}([&](auto i) { operator()(i) = a[i]; });
  
         return *this;
     }
  
     private:
     Arr& mArray;
 };
  
 // Arr: Array or StaticallyIndexedArray
 // Picks: Sequence<...>
 template <typename Arr, typename Picks>
 struct ConstantContainerElementPicker
 {
     using type = ConstantContainerElementPicker;
 #if 0
     using data_type = typename Arr::data_type;
 #endif
  
     __host__ __device__ constexpr ConstantContainerElementPicker() = delete;
  
     __host__ __device__ constexpr ConstantContainerElementPicker(const Arr& array) : mArray{array}
     {
         constexpr index_t imax =
             reduce_on_sequence(Picks{}, math::maximize<index_t>{}, Number<0>{});
  
         static_assert(imax < Arr::Size(), "wrong! exceeding # array element");
     }
  
     __host__ __device__ static constexpr auto Size() { return Picks::Size(); }
  
     template <index_t I>
     __host__ __device__ constexpr const auto& At(Number<I> i) const
     {
         static_assert(I < Size(), "wrong!");
  
         constexpr auto IP = Picks{}[i];
         return mArray[IP];
     }
  
     template <index_t I>
     __host__ __device__ constexpr const auto& operator[](Number<I> i) const
     {
         return At(i);
     }
  
     private:
     const Arr& mArray;
 };
  
 template <typename Arr, typename Picks, typename X>
 __host__ __device__ constexpr auto operator+=(ContainerElementPicker<Arr, Picks>& y, const X& x)
 {
     using Y                 = ContainerElementPicker<Arr, Picks>;
     constexpr index_t nsize = Y::Size();
  
     static_assert(nsize == X::Size(), "wrong! size not the same");
  
     static_for<0, nsize, 1>{}([&](auto i) { y(i) += x[i]; });
  
     return y;
 }
  
 template <typename Arr, typename Picks, typename X>
 __host__ __device__ constexpr auto operator-=(ContainerElementPicker<Arr, Picks>& y, const X& x)
 {
     using Y                 = ContainerElementPicker<Arr, Picks>;
     constexpr index_t nsize = Y::Size();
  
     static_assert(nsize == X::Size(), "wrong! size not the same");
  
     static_for<0, nsize, 1>{}([&](auto i) { y(i) -= x[i]; });
  
     return y;
 }
  
 template <typename Arr, typename Picks>
 __host__ __device__ constexpr auto pick_container_element(Arr& a, Picks)
 {
     return ContainerElementPicker<Arr, Picks>(a);
 }
  
 template <typename Arr, typename Picks>
 __host__ __device__ constexpr auto pick_container_element(const Arr& a, Picks)
 {
     return ConstantContainerElementPicker<Arr, Picks>(a);
 }
  
 } // namespace ck
 #endif