mirror of
https://github.com/ROCm/composable_kernel.git
synced 2026-04-19 14:29:05 +00:00
2e3183af4f
* updating codegen build for MIOpen access: adding .cmake for codegen component * updating CMake * adding in header guards for some headers due to issues with hiprtc compilation in MIOpen * some more header guards * putting env file in header guard * cleaning up some includes * updated types file for hiprtc purposes * fixed types file: bit-wise/memcpy issue * updating multiple utility files to deal with standard header inclusion for hiprtc * added some more header guards in the utility files, replacing some standard header functionality * added some more header guards * fixing some conflicts in utility files, another round of header guards * fixing errors in data type file * resolved conflict errors in a few utility files * added header guards/replicated functionality in device files * resolved issues with standard headers in device files: device_base and device_grouped_conv_fwd_multiple_abd * resolved issues with standard headers in device files: device_base.hpp, device_grouped_conv_fwd_multiple_abd.hpp, device_grouped_conv_fwd_multiple_abd_xdl_cshuffle.hpp * added header guards for gridwise gemm files: gridwise_gemm_multiple_abd_xdl_cshuffle.hpp and gridwise_gemm_multiple_d_xdl_cshuffle.hpp * fixed issue with numerics header, removed from transform_conv_fwd_to_gemm and added to device_column_to_image_impl, device_grouped_conv_fwd_multiple_abd_xdl_cshuffle, device_grouped_conv_fwd_multiple_abd_xdl_cshuffle_v3, device_image_to_column_impl * replaced standard header usage and added header guards in block to ctile map and gridwise_gemm_pipeline_selector * resolved errors in device_gemm_xdl_splitk_c_shuffle files in regards to replacement of standard headers in previous commit * added replicated functionality for standard header methods in utility files * replaced standard header functionality in threadwise tensor slice transfer files and added header guards in element_wise_operation.hpp * temp fix for namespace error in MIOpen * remove standard header usage in codegen device op * removed standard header usage in elementwise files, resolved namespace errors * formatting fix * changed codegen argument to ON for testing * temporarily removing codegen compiler flag for testing purposes * added codegen flag again, set default to ON * set codegen flag default back to OFF * replaced enable_if_t standard header usage in data_type.hpp * added some debug prints to pinpoint issues in MIOpen * added print outs to debug in MIOpen * removed debug print outs from device op * resolved stdexcept include error * formatting fix * adding includes to new fp8 file to resolve ck::enable_if_t errors * made changes to amd_wave_read_first_lane * updated functionality in type utility file * fixed end of file issue * resovled errors in type utility file, added functionality to array utility file * fixed standard header usage replication in data_type file, resolves error with failing examples on navi3x * formatting fix * replaced standard header usage in amd_ck_fp8 file * added include to random_gen file * removed and replicated standard header usage from data_type and type_convert files for fp8 changes * replicated standard unsigned integer types in random_gen * resolved comments from review: put calls to reinterpret_cast for size_t in header guards * updated/added copyright headers * removed duplicate header * fixed typo in header guard * updated copyright headers --------- Co-authored-by: Illia Silin <98187287+illsilin@users.noreply.github.com>
132 lines
2.7 KiB
C++
132 lines
2.7 KiB
C++
// SPDX-License-Identifier: MIT
|
|
// Copyright (c) 2018-2025, Advanced Micro Devices, Inc. All rights reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "ck/utility/integral_constant.hpp"
|
|
#include "ck/utility/type.hpp"
|
|
|
|
namespace ck {
|
|
|
|
// TODO: right? wrong?
|
|
struct forwarder
|
|
{
|
|
template <typename T>
|
|
__host__ __device__ constexpr T&& operator()(T&& x) const
|
|
{
|
|
return static_cast<T&&>(x);
|
|
}
|
|
};
|
|
|
|
struct swallow
|
|
{
|
|
template <typename... Ts>
|
|
__host__ __device__ constexpr swallow(Ts&&...)
|
|
{
|
|
}
|
|
};
|
|
|
|
template <typename T>
|
|
struct logical_and
|
|
{
|
|
constexpr bool operator()(const T& x, const T& y) const { return x && y; }
|
|
};
|
|
|
|
template <typename T>
|
|
struct logical_or
|
|
{
|
|
constexpr bool operator()(const T& x, const T& y) const { return x || y; }
|
|
};
|
|
|
|
template <typename T>
|
|
struct logical_not
|
|
{
|
|
constexpr bool operator()(const T& x) const { return !x; }
|
|
};
|
|
|
|
// Emulate if constexpr
|
|
template <bool>
|
|
struct static_if;
|
|
|
|
template <>
|
|
struct static_if<true>
|
|
{
|
|
using Type = static_if<true>;
|
|
|
|
template <typename F>
|
|
__host__ __device__ constexpr auto operator()(F f) const
|
|
{
|
|
// This is a trick for compiler:
|
|
// Pass forwarder to lambda "f" as "auto" argument, and make sure "f" will
|
|
// use it,
|
|
// this will make "f" a generic lambda, so that "f" won't be compiled
|
|
// until being
|
|
// instantiated here
|
|
f(forwarder{});
|
|
return Type{};
|
|
}
|
|
|
|
template <typename F>
|
|
__host__ __device__ static void Else(F)
|
|
{
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct static_if<false>
|
|
{
|
|
using Type = static_if<false>;
|
|
|
|
template <typename F>
|
|
__host__ __device__ constexpr auto operator()(F) const
|
|
{
|
|
return Type{};
|
|
}
|
|
|
|
template <typename F>
|
|
__host__ __device__ static void Else(F f)
|
|
{
|
|
// This is a trick for compiler:
|
|
// Pass forwarder to lambda "f" as "auto" argument, and make sure "f" will
|
|
// use it,
|
|
// this will make "f" a generic lambda, so that "f" won't be compiled
|
|
// until being
|
|
// instantiated here
|
|
f(forwarder{});
|
|
}
|
|
};
|
|
|
|
template <bool predicate, class X, class Y>
|
|
struct conditional;
|
|
|
|
template <class X, class Y>
|
|
struct conditional<true, X, Y>
|
|
{
|
|
using type = X;
|
|
};
|
|
|
|
template <class X, class Y>
|
|
struct conditional<false, X, Y>
|
|
{
|
|
using type = Y;
|
|
};
|
|
|
|
template <bool predicate, class X, class Y>
|
|
using conditional_t = typename conditional<predicate, X, Y>::type;
|
|
|
|
// z = predicate ? x : y
|
|
template <bool predicate, typename X, typename Y>
|
|
constexpr auto conditional_expr(X&& x, Y&& y)
|
|
{
|
|
if constexpr(predicate)
|
|
{
|
|
return ck::forward<X>(x);
|
|
}
|
|
else
|
|
{
|
|
return ck::forward<Y>(y);
|
|
}
|
|
}
|
|
|
|
} // namespace ck
|