triton-windows 3.2.0.post18__cp39-cp39-win_amd64.whl → 3.2.0.post21__cp39-cp39-win_amd64.whl

triton/backends/amd/include/hip/amd_detail/hip_assert.h

@@ -1,101 +0,0 @@
-/*
-Copyright (c) 2023 Advanced Micro Devices, Inc. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-#pragma once
-
-// abort
-extern "C" __device__ inline __attribute__((weak))
-void abort() {
-  __builtin_trap();
-}
-
-// The noinline attribute helps encapsulate the printf expansion,
-// which otherwise has a performance impact just by increasing the
-// size of the calling function. Additionally, the weak attribute
-// allows the function to exist as a global although its definition is
-// included in every compilation unit.
-#if defined(_WIN32) || defined(_WIN64)
-extern "C" __device__ __attribute__((noinline)) __attribute__((weak))
-void _wassert(const wchar_t *_msg, const wchar_t *_file, unsigned _line) {
-    // FIXME: Need `wchar_t` support to generate assertion message.
-    __builtin_trap();
-}
-#else /* defined(_WIN32) || defined(_WIN64) */
-extern "C" __device__ __attribute__((noinline)) __attribute__((weak))
-void __assert_fail(const char *assertion,
-                   const char *file,
-                   unsigned int line,
-                   const char *function)
-{
-  const char fmt[] = "%s:%u: %s: Device-side assertion `%s' failed.\n";
-
-  // strlen is not available as a built-in yet, so we create our own
-  // loop in a macro. With a string literal argument, the compiler
-  // usually manages to replace the loop with a constant.
-  //
-  // The macro does not check for null pointer, since all the string
-  // arguments are defined to be constant literals when called from
-  // the assert() macro.
-  //
-  // NOTE: The loop below includes the null terminator in the length
-  // as required by append_string_n().
-#define __hip_get_string_length(LEN, STR)       \
-  do {                                          \
-    const char *tmp = STR;                      \
-    while (*tmp++);                             \
-    LEN = tmp - STR;                            \
-  } while (0)
-
-  auto msg = __ockl_fprintf_stderr_begin();
-  int len = 0;
-  __hip_get_string_length(len, fmt);
-  msg = __ockl_fprintf_append_string_n(msg, fmt, len, 0);
-  __hip_get_string_length(len, file);
-  msg = __ockl_fprintf_append_string_n(msg, file, len, 0);
-  msg = __ockl_fprintf_append_args(msg, 1, line, 0, 0, 0, 0, 0, 0, 0);
-  __hip_get_string_length(len, function);
-  msg = __ockl_fprintf_append_string_n(msg, function, len, 0);
-  __hip_get_string_length(len, assertion);
-  __ockl_fprintf_append_string_n(msg, assertion, len, /* is_last = */ 1);
-
-#undef __hip_get_string_length
-
-  __builtin_trap();
-}
-
-extern "C" __device__ __attribute__((noinline)) __attribute__((weak))
-void __assertfail()
-{
-    // ignore all the args for now.
-    __builtin_trap();
-}
-#endif /* defined(_WIN32) || defined(_WIN64) */
-
-#if defined(NDEBUG)
-#define __hip_assert(COND)
-#else
-#define __hip_assert(COND)                          \
-  do {                                              \
-    if (!(COND))                                    \
-      __builtin_trap();                             \
-  } while (0)
-#endif

triton/backends/amd/include/hip/amd_detail/hip_cooperative_groups_helper.h

@@ -1,242 +0,0 @@
-/*
-Copyright (c) 2015 - 2023 Advanced Micro Devices, Inc. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-/**
- *  @file  amd_detail/hip_cooperative_groups_helper.h
- *
- *  @brief Device side implementation of cooperative group feature.
- *
- *  Defines helper constructs and APIs which aid the types and device API
- *  wrappers defined within `amd_detail/hip_cooperative_groups.h`.
- */
-#ifndef HIP_INCLUDE_HIP_AMD_DETAIL_HIP_COOPERATIVE_GROUPS_HELPER_H
-#define HIP_INCLUDE_HIP_AMD_DETAIL_HIP_COOPERATIVE_GROUPS_HELPER_H
-
-#if __cplusplus
-#if !defined(__HIPCC_RTC__)
-#include <hip/amd_detail/amd_hip_runtime.h> // threadId, blockId
-#include <hip/amd_detail/amd_device_functions.h>
-#endif
-#if !defined(__align__)
-#define __align__(x) __attribute__((aligned(x)))
-#endif
-
-#if !defined(__CG_QUALIFIER__)
-#define __CG_QUALIFIER__ __device__ __forceinline__
-#endif
-
-#if !defined(__CG_STATIC_QUALIFIER__)
-#define __CG_STATIC_QUALIFIER__ __device__ static __forceinline__
-#endif
-
-#if !defined(_CG_STATIC_CONST_DECL_)
-#define _CG_STATIC_CONST_DECL_ static constexpr
-#endif
-
-#if __AMDGCN_WAVEFRONT_SIZE == 32
-using lane_mask = unsigned int;
-#else
-using lane_mask = unsigned long long int;
-#endif
-
-namespace cooperative_groups {
-
-/* Global scope */
-template <unsigned int size>
-using is_power_of_2 = std::integral_constant<bool, (size & (size - 1)) == 0>;
-
-template <unsigned int size>
-using is_valid_wavefront = std::integral_constant<bool, (size <= __AMDGCN_WAVEFRONT_SIZE)>;
-
-template <unsigned int size>
-using is_valid_tile_size =
-    std::integral_constant<bool, is_power_of_2<size>::value && is_valid_wavefront<size>::value>;
-
-template <typename T>
-using is_valid_type =
-    std::integral_constant<bool, std::is_integral<T>::value || std::is_floating_point<T>::value>;
-
-namespace internal {
-
-/**
-* @brief Enums representing different cooperative group types
-* @note  This enum is only applicable on Linux.
-*
- */
-typedef enum {
-  cg_invalid,
-  cg_multi_grid,
-  cg_grid,
-  cg_workgroup,
-  cg_tiled_group,
-  cg_coalesced_group
-} group_type;
-/**
- *  @ingroup CooperativeG
- *  @{
- *  This section describes the cooperative groups functions of HIP runtime API.
- *  
- *  The cooperative groups provides flexible thread parallel programming algorithms, threads
- *  cooperate and share data to perform collective computations.
- *
- *  @note  Cooperative groups feature is implemented on Linux, under developement
- *  on Windows.
- *
- */
-/**
- *
- * @brief  Functionalities related to multi-grid cooperative group type
- * @note  The following cooperative groups functions are only applicable on Linux.
- *
- */
-namespace multi_grid {
-
-__CG_STATIC_QUALIFIER__ uint32_t num_grids() {
-  return static_cast<uint32_t>(__ockl_multi_grid_num_grids()); }
-
-__CG_STATIC_QUALIFIER__ uint32_t grid_rank() {
-  return static_cast<uint32_t>(__ockl_multi_grid_grid_rank()); }
-
-__CG_STATIC_QUALIFIER__ uint32_t size() { return static_cast<uint32_t>(__ockl_multi_grid_size()); }
-
-__CG_STATIC_QUALIFIER__ uint32_t thread_rank() {
-  return static_cast<uint32_t>(__ockl_multi_grid_thread_rank()); }
-
-__CG_STATIC_QUALIFIER__ bool is_valid() { return static_cast<bool>(__ockl_multi_grid_is_valid()); }
-
-__CG_STATIC_QUALIFIER__ void sync() { __ockl_multi_grid_sync(); }
-
-}  // namespace multi_grid
-
-/**
- *  @brief Functionalities related to grid cooperative group type
- *  @note  The following cooperative groups functions are only applicable on Linux.
- */
-namespace grid {
-
-__CG_STATIC_QUALIFIER__ uint32_t size() {
-  return static_cast<uint32_t>((blockDim.z * gridDim.z) * (blockDim.y * gridDim.y) *
-                    (blockDim.x * gridDim.x));
-}
-
-__CG_STATIC_QUALIFIER__ uint32_t thread_rank() {
-  // Compute global id of the workgroup to which the current thread belongs to
-  uint32_t blkIdx = static_cast<uint32_t>((blockIdx.z * gridDim.y * gridDim.x) +
-                               (blockIdx.y * gridDim.x) + (blockIdx.x));
-
-  // Compute total number of threads being passed to reach current workgroup
-  // within grid
-  uint32_t num_threads_till_current_workgroup =
-      static_cast<uint32_t>(blkIdx * (blockDim.x * blockDim.y * blockDim.z));
-
-  // Compute thread local rank within current workgroup
-  uint32_t local_thread_rank = static_cast<uint32_t>((threadIdx.z * blockDim.y * blockDim.x) +
-                                          (threadIdx.y * blockDim.x) + (threadIdx.x));
-
-  return (num_threads_till_current_workgroup + local_thread_rank);
-}
-
-__CG_STATIC_QUALIFIER__ bool is_valid() { return static_cast<bool>(__ockl_grid_is_valid()); }
-
-__CG_STATIC_QUALIFIER__ void sync() { __ockl_grid_sync(); }
-
-}  // namespace grid
-
-/**
- *  @brief Functionalities related to `workgroup` (thread_block in CUDA terminology)
- *  cooperative group type
- *  @note  The following cooperative groups functions are only applicable on Linux.
- */
-namespace workgroup {
-
-__CG_STATIC_QUALIFIER__ dim3 group_index() {
-  return (dim3(static_cast<uint32_t>(blockIdx.x), static_cast<uint32_t>(blockIdx.y),
-               static_cast<uint32_t>(blockIdx.z)));
-}
-
-__CG_STATIC_QUALIFIER__ dim3 thread_index() {
-  return (dim3(static_cast<uint32_t>(threadIdx.x), static_cast<uint32_t>(threadIdx.y),
-               static_cast<uint32_t>(threadIdx.z)));
-}
-
-__CG_STATIC_QUALIFIER__ uint32_t size() {
-  return (static_cast<uint32_t>(blockDim.x * blockDim.y * blockDim.z));
-}
-
-__CG_STATIC_QUALIFIER__ uint32_t thread_rank() {
-  return (static_cast<uint32_t>((threadIdx.z * blockDim.y * blockDim.x) +
-                     (threadIdx.y * blockDim.x) + (threadIdx.x)));
-}
-
-__CG_STATIC_QUALIFIER__ bool is_valid() {
-  return true;
-}
-
-__CG_STATIC_QUALIFIER__ void sync() { __syncthreads(); }
-
-__CG_STATIC_QUALIFIER__ dim3 block_dim() {
-  return (dim3(static_cast<uint32_t>(blockDim.x), static_cast<uint32_t>(blockDim.y),
-          static_cast<uint32_t>(blockDim.z)));
-}
-
-}  // namespace workgroup
-
-namespace tiled_group {
-
-// enforce ordering for memory intructions
-__CG_STATIC_QUALIFIER__ void sync() { __builtin_amdgcn_fence(__ATOMIC_ACQ_REL, "agent"); }
-
-}  // namespace tiled_group
-
-namespace coalesced_group {
-
-// enforce ordering for memory intructions
-__CG_STATIC_QUALIFIER__ void sync() { __builtin_amdgcn_fence(__ATOMIC_ACQ_REL, "agent"); }
-
-// Masked bit count
-//
-// For each thread, this function returns the number of active threads which
-// have i-th bit of x set and come before the current thread.
-__CG_STATIC_QUALIFIER__ unsigned int masked_bit_count(lane_mask x, unsigned int add = 0) {
-  unsigned int counter=0;
-    #if __AMDGCN_WAVEFRONT_SIZE == 32
-      counter = __builtin_amdgcn_mbcnt_lo(x, add);
-    #else
-      counter = __builtin_amdgcn_mbcnt_lo(static_cast<lane_mask>(x), add);
-      counter = __builtin_amdgcn_mbcnt_hi(static_cast<lane_mask>(x >> 32), counter);
-    #endif
-
-    return counter;
-}
-
-}  // namespace coalesced_group
-
-
-}  // namespace internal
-
-}  // namespace cooperative_groups
-/**
-*  @}
-*/
-
-#endif  // __cplusplus
-#endif  // HIP_INCLUDE_HIP_AMD_DETAIL_HIP_COOPERATIVE_GROUPS_HELPER_H

triton/backends/amd/include/hip/amd_detail/hip_fp16_gcc.h

@@ -1,254 +0,0 @@
-#pragma once
-
-#if defined(__cplusplus)
-    #include <cstring>
-#endif
-
-struct __half_raw {
-    unsigned short x;
-};
-
-struct __half2_raw {
-    unsigned short x;
-    unsigned short y;
-};
-
-#if defined(__cplusplus)
-    struct __half;
-
-    __half __float2half(float);
-    float __half2float(__half);
-
-    // BEGIN STRUCT __HALF
-    struct __half {
-    protected:
-        unsigned short __x;
-    public:
-        // CREATORS
-        __half() = default;
-        __half(const __half_raw& x) : __x{x.x} {}
-        #if !defined(__HIP_NO_HALF_CONVERSIONS__)
-            __half(float x) : __x{__float2half(x).__x} {}
-            __half(double x) : __x{__float2half(x).__x} {}
-        #endif
-        __half(const __half&) = default;
-        __half(__half&&) = default;
-        ~__half() = default;
-
-        // MANIPULATORS
-        __half& operator=(const __half&) = default;
-        __half& operator=(__half&&) = default;
-        __half& operator=(const __half_raw& x) { __x = x.x; return *this; }
-        #if !defined(__HIP_NO_HALF_CONVERSIONS__)
-            __half& operator=(float x)
-            {
-                __x = __float2half(x).__x;
-                return *this;
-            }
-            __half& operator=(double x)
-            {
-                return *this = static_cast<float>(x);
-            }
-        #endif
-
-        // ACCESSORS
-        operator float() const { return __half2float(*this); }
-        operator __half_raw() const { return __half_raw{__x}; }
-    };
-    // END STRUCT __HALF
-
-    // BEGIN STRUCT __HALF2
-    struct __half2 {
-    public:
-        __half x;
-        __half y;
-
-        // CREATORS
-        __half2() = default;
-        __half2(const __half2_raw& ix)
-            :
-            x{reinterpret_cast<const __half&>(ix.x)},
-            y{reinterpret_cast<const __half&>(ix.y)}
-        {}
-        __half2(const __half& ix, const __half& iy) : x{ix}, y{iy} {}
-        __half2(const __half2&) = default;
-        __half2(__half2&&) = default;
-        ~__half2() = default;
-
-        // MANIPULATORS
-        __half2& operator=(const __half2&) = default;
-        __half2& operator=(__half2&&) = default;
-        __half2& operator=(const __half2_raw& ix)
-        {
-            x = reinterpret_cast<const __half_raw&>(ix.x);
-            y = reinterpret_cast<const __half_raw&>(ix.y);
-            return *this;
-        }
-
-        // ACCESSORS
-        operator __half2_raw() const
-        {
-            return __half2_raw{
-                reinterpret_cast<const unsigned short&>(x),
-                reinterpret_cast<const unsigned short&>(y)};
-        }
-    };
-    // END STRUCT __HALF2
-
-    inline
-    unsigned short __internal_float2half(
-        float flt, unsigned int& sgn, unsigned int& rem)
-    {
-        unsigned int x{};
-        std::memcpy(&x, &flt, sizeof(flt));
-
-        unsigned int u = (x & 0x7fffffffU);
-        sgn = ((x >> 16) & 0x8000U);
-
-        // NaN/+Inf/-Inf
-        if (u >= 0x7f800000U) {
-            rem = 0;
-            return static_cast<unsigned short>(
-                (u == 0x7f800000U) ? (sgn | 0x7c00U) : 0x7fffU);
-        }
-        // Overflows
-        if (u > 0x477fefffU) {
-            rem = 0x80000000U;
-            return static_cast<unsigned short>(sgn | 0x7bffU);
-        }
-        // Normal numbers
-        if (u >= 0x38800000U) {
-            rem = u << 19;
-            u -= 0x38000000U;
-            return static_cast<unsigned short>(sgn | (u >> 13));
-        }
-        // +0/-0
-        if (u < 0x33000001U) {
-            rem = u;
-            return static_cast<unsigned short>(sgn);
-        }
-        // Denormal numbers
-        unsigned int exponent = u >> 23;
-        unsigned int mantissa = (u & 0x7fffffU);
-        unsigned int shift = 0x7eU - exponent;
-        mantissa |= 0x800000U;
-        rem = mantissa << (32 - shift);
-        return static_cast<unsigned short>(sgn | (mantissa >> shift));
-    }
-
-    inline
-    __half __float2half(float x)
-    {
-        __half_raw r;
-        unsigned int sgn{};
-        unsigned int rem{};
-        r.x = __internal_float2half(x, sgn, rem);
-        if (rem > 0x80000000U || (rem == 0x80000000U && (r.x & 0x1))) ++r.x;
-
-        return r;
-    }
-
-    inline
-    __half __float2half_rn(float x) { return __float2half(x); }
-
-    inline
-    __half __float2half_rz(float x)
-    {
-        __half_raw r;
-        unsigned int sgn{};
-        unsigned int rem{};
-        r.x = __internal_float2half(x, sgn, rem);
-
-        return r;
-    }
-
-    inline
-    __half __float2half_rd(float x)
-    {
-        __half_raw r;
-        unsigned int sgn{};
-        unsigned int rem{};
-        r.x = __internal_float2half(x, sgn, rem);
-        if (rem && sgn) ++r.x;
-
-        return r;
-    }
-
-    inline
-    __half __float2half_ru(float x)
-    {
-        __half_raw r;
-        unsigned int sgn{};
-        unsigned int rem{};
-        r.x = __internal_float2half(x, sgn, rem);
-        if (rem && !sgn) ++r.x;
-
-        return r;
-    }
-
-    inline
-    __half2 __float2half2_rn(float x)
-    {
-        return __half2{__float2half_rn(x), __float2half_rn(x)};
-    }
-
-    inline
-    __half2 __floats2half2_rn(float x, float y)
-    {
-        return __half2{__float2half_rn(x), __float2half_rn(y)};
-    }
-
-    inline
-    float __internal_half2float(unsigned short x)
-    {
-        unsigned int sign = ((x >> 15) & 1);
-        unsigned int exponent = ((x >> 10) & 0x1f);
-        unsigned int mantissa = ((x & 0x3ff) << 13);
-
-        if (exponent == 0x1fU) { /* NaN or Inf */
-            mantissa = (mantissa ? (sign = 0, 0x7fffffU) : 0);
-            exponent = 0xffU;
-        } else if (!exponent) { /* Denorm or Zero */
-            if (mantissa) {
-                unsigned int msb;
-                exponent = 0x71U;
-                do {
-                    msb = (mantissa & 0x400000U);
-                    mantissa <<= 1; /* normalize */
-                    --exponent;
-                } while (!msb);
-                mantissa &= 0x7fffffU; /* 1.mantissa is implicit */
-            }
-        } else {
-            exponent += 0x70U;
-        }
-        unsigned int u = ((sign << 31) | (exponent << 23) | mantissa);
-        float f;
-        memcpy(&f, &u, sizeof(u));
-
-        return f;
-    }
-
-    inline
-    float __half2float(__half x)
-    {
-        return __internal_half2float(static_cast<__half_raw>(x).x);
-    }
-
-    inline
-    float __low2float(__half2 x)
-    {
-        return __internal_half2float(static_cast<__half2_raw>(x).x);
-    }
-
-    inline
-    float __high2float(__half2 x)
-    {
-        return __internal_half2float(static_cast<__half2_raw>(x).y);
-    }
-
-    #if !defined(HIP_NO_HALF)
-        using half = __half;
-        using half2 = __half2;
-    #endif
-#endif // defined(__cplusplus)

triton/backends/amd/include/hip/amd_detail/hip_fp16_math_fwd.h

@@ -1,96 +0,0 @@
-/*
-Copyright (c) 2015 - 2023 Advanced Micro Devices, Inc. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-#pragma once
-
-// /*
-// Half Math Functions
-// */
-#if !defined(__HIPCC_RTC__)
-#include "host_defines.h"
-#endif
-#ifndef __CLANG_HIP_RUNTIME_WRAPPER_INCLUDED__
-extern "C"
-{
-    __device__ __attribute__((const)) _Float16 __ocml_ceil_f16(_Float16);
-    __device__ _Float16 __ocml_cos_f16(_Float16);
-    __device__ __attribute__((pure)) _Float16 __ocml_exp_f16(_Float16);
-    __device__ __attribute__((pure)) _Float16 __ocml_exp10_f16(_Float16);
-    __device__ __attribute__((pure)) _Float16 __ocml_exp2_f16(_Float16);
-    __device__ __attribute__((const)) _Float16 __ocml_floor_f16(_Float16);
-    __device__ __attribute__((const))
-    _Float16 __ocml_fma_f16(_Float16, _Float16, _Float16);
-    __device__ __attribute__((const)) _Float16 __ocml_fabs_f16(_Float16);
-    __device__ __attribute__((const)) int __ocml_isinf_f16(_Float16);
-    __device__ __attribute__((const)) int __ocml_isnan_f16(_Float16);
-    __device__ __attribute__((pure)) _Float16 __ocml_log_f16(_Float16);
-    __device__ __attribute__((pure)) _Float16 __ocml_log10_f16(_Float16);
-    __device__ __attribute__((pure)) _Float16 __ocml_log2_f16(_Float16);
-    __device__ __attribute__((pure)) _Float16 __ocml_pown_f16(_Float16, int);
-    __device__ __attribute__((const)) _Float16 __ocml_rint_f16(_Float16);
-    __device__ __attribute__((const)) _Float16 __ocml_rsqrt_f16(_Float16);
-    __device__ _Float16 __ocml_sin_f16(_Float16);
-    __device__ __attribute__((const)) _Float16 __ocml_sqrt_f16(_Float16);
-    __device__ __attribute__((const)) _Float16 __ocml_trunc_f16(_Float16);
-    __device__ __attribute__((const)) _Float16 __ocml_fmax_f16(_Float16, _Float16);
-    __device__ __attribute__((const)) _Float16 __ocml_fmin_f16(_Float16, _Float16);
-
-    typedef _Float16 __2f16 __attribute__((ext_vector_type(2)));
-    typedef short __2i16 __attribute__((ext_vector_type(2)));
-
-    #if defined(__clang__) && defined(__HIP__)
-    __device__ __attribute__((const)) float __ockl_fdot2(__2f16 a, __2f16 b, float c, bool s);
-    #endif
-
-    __device__ __attribute__((const)) __2f16 __ocml_ceil_2f16(__2f16);
-    __device__ __attribute__((const)) __2f16 __ocml_fabs_2f16(__2f16);
-    __device__ __2f16 __ocml_cos_2f16(__2f16);
-    __device__ __attribute__((pure)) __2f16 __ocml_exp_2f16(__2f16);
-    __device__ __attribute__((pure)) __2f16 __ocml_exp10_2f16(__2f16);
-    __device__ __attribute__((pure)) __2f16 __ocml_exp2_2f16(__2f16);
-    __device__ __attribute__((const)) __2f16 __ocml_floor_2f16(__2f16);
-    __device__ __attribute__((const)) __2f16 __ocml_fma_2f16(__2f16, __2f16, __2f16);
-    __device__ __attribute__((const)) __2i16 __ocml_isinf_2f16(__2f16);
-    __device__ __attribute__((const)) __2i16 __ocml_isnan_2f16(__2f16);
-    __device__ __attribute__((pure)) __2f16 __ocml_log_2f16(__2f16);
-    __device__ __attribute__((pure)) __2f16 __ocml_log10_2f16(__2f16);
-    __device__ __attribute__((pure)) __2f16 __ocml_log2_2f16(__2f16);
-    __device__ __attribute__((const)) __2f16 __ocml_rint_2f16(__2f16);
-    __device__ __attribute__((const)) __2f16 __ocml_rsqrt_2f16(__2f16);
-    __device__ __2f16 __ocml_sin_2f16(__2f16);
-    __device__ __attribute__((const)) __2f16 __ocml_sqrt_2f16(__2f16);
-    __device__ __attribute__((const)) __2f16 __ocml_trunc_2f16(__2f16);
-
-    __device__ __attribute__((const)) _Float16 __ocml_cvtrtn_f16_f32(float);
-    __device__ __attribute__((const)) _Float16 __ocml_cvtrtp_f16_f32(float);
-    __device__ __attribute__((const)) _Float16 __ocml_cvtrtz_f16_f32(float);
-
-}
-#endif // !__CLANG_HIP_RUNTIME_WRAPPER_INCLUDED__
-//TODO: remove these after they get into clang header __clang_hip_libdevice_declares.h'
-extern "C" {
-    __device__ __attribute__((const)) _Float16 __ocml_fmax_f16(_Float16, _Float16);
-    __device__ __attribute__((const)) _Float16 __ocml_fmin_f16(_Float16, _Float16);
-    __device__ __attribute__((const)) _Float16 __ocml_cvtrtn_f16_f32(float);
-    __device__ __attribute__((const)) _Float16 __ocml_cvtrtp_f16_f32(float);
-    __device__ __attribute__((const)) _Float16 __ocml_cvtrtz_f16_f32(float);
-}