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

triton/backends/amd/include/hip/amd_detail/functional_grid_launch.hpp

@@ -1,218 +0,0 @@
-/*
-Copyright (c) 2015 - 2021 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
-
-#include "concepts.hpp"
-#include "helpers.hpp"
-#include "program_state.hpp"
-#include "hip_runtime_api.h"
-
-#include <cstdint>
-#include <cstring>
-#include <stdexcept>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-hipError_t ihipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices,
-                                               unsigned int flags, hip_impl::program_state& ps);
-
-hipError_t hipLaunchCooperativeKernel(const void* f, dim3 gridDim,
-                                    dim3 blockDim, void** args,
-                                    size_t sharedMem, hipStream_t stream,
-                                    hip_impl::program_state& ps);
-
-hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,
-                                                 int  numDevices,
-                                                 unsigned int flags,
-                                                 hip_impl::program_state& ps);
-
-#pragma GCC visibility push(hidden)
-
-namespace hip_impl {
-template <typename T, typename std::enable_if<std::is_integral<T>{}>::type* = nullptr>
-inline T round_up_to_next_multiple_nonnegative(T x, T y) {
-    T tmp = x + y - 1;
-    return tmp - tmp % y;
-}
-
-template <
-    std::size_t n,
-    typename... Ts,
-    typename std::enable_if<n == sizeof...(Ts)>::type* = nullptr>
-inline hip_impl::kernarg make_kernarg(
-    const std::tuple<Ts...>&,
-    const kernargs_size_align&,
-    hip_impl::kernarg kernarg) {
-    return kernarg;
-}
-
-template <
-    std::size_t n,
-    typename... Ts,
-    typename std::enable_if<n != sizeof...(Ts)>::type* = nullptr>
-inline hip_impl::kernarg make_kernarg(
-    const std::tuple<Ts...>& formals,
-    const kernargs_size_align& size_align,
-    hip_impl::kernarg kernarg) {
-    using T = typename std::tuple_element<n, std::tuple<Ts...>>::type;
-
-    static_assert(
-        !std::is_reference<T>{},
-        "A __global__ function cannot have a reference as one of its "
-            "arguments.");
-    #if defined(HIP_STRICT)
-        static_assert(
-            std::is_trivially_copyable<T>{},
-            "Only TriviallyCopyable types can be arguments to a __global__ "
-                "function");
-    #endif
-
-    kernarg.resize(round_up_to_next_multiple_nonnegative(
-        kernarg.size(), size_align.alignment(n)) + size_align.size(n));
-
-    std::memcpy(
-        kernarg.data() + kernarg.size() - size_align.size(n),
-        &std::get<n>(formals),
-        size_align.size(n));
-    return make_kernarg<n + 1>(formals, size_align, std::move(kernarg));
-}
-
-template <typename... Formals, typename... Actuals>
-inline hip_impl::kernarg make_kernarg(
-    void (*kernel)(Formals...), std::tuple<Actuals...> actuals) {
-    static_assert(sizeof...(Formals) == sizeof...(Actuals),
-        "The count of formal arguments must match the count of actuals.");
-
-    if (sizeof...(Formals) == 0) return {};
-
-    std::tuple<Formals...> to_formals{std::move(actuals)};
-    hip_impl::kernarg kernarg;
-    kernarg.reserve(sizeof(to_formals));
-
-    auto& ps = hip_impl::get_program_state();
-    return make_kernarg<0>(to_formals, 
-                           ps.get_kernargs_size_align(
-                               reinterpret_cast<std::uintptr_t>(kernel)),
-                           std::move(kernarg));
-}
-
-
-HIP_INTERNAL_EXPORTED_API hsa_agent_t target_agent(hipStream_t stream);
-
-inline
-__attribute__((visibility("hidden")))
-void hipLaunchKernelGGLImpl(
-    std::uintptr_t function_address,
-    const dim3& numBlocks,
-    const dim3& dimBlocks,
-    std::uint32_t sharedMemBytes,
-    hipStream_t stream,
-    void** kernarg) {
-
-    const auto& kd = hip_impl::get_program_state().kernel_descriptor(function_address, 
-                                                               target_agent(stream));
-
-    hipModuleLaunchKernel(kd, numBlocks.x, numBlocks.y, numBlocks.z,
-                          dimBlocks.x, dimBlocks.y, dimBlocks.z, sharedMemBytes,
-                          stream, nullptr, kernarg);
-}
-} // Namespace hip_impl.
-
-
-template <class T>
-inline
-hipError_t hipOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize,
-    T kernel, size_t dynSharedMemPerBlk = 0, int blockSizeLimit = 0) {
-
-    using namespace hip_impl;
-
-    hip_impl::hip_init();
-    auto f = get_program_state().kernel_descriptor(reinterpret_cast<std::uintptr_t>(kernel),
-                                                   target_agent(0));
-
-    return hipModuleOccupancyMaxPotentialBlockSize(gridSize, blockSize, f,
-                                      dynSharedMemPerBlk, blockSizeLimit);
-}
-
-template <class T>
-inline
-hipError_t hipOccupancyMaxPotentialBlockSizeWithFlags(int* gridSize, int* blockSize,
-    T kernel, size_t dynSharedMemPerBlk = 0, int blockSizeLimit = 0, unsigned int  flags = 0 ) {
-
-    using namespace hip_impl;
-
-    hip_impl::hip_init();
-    if(flags != hipOccupancyDefault) return hipErrorNotSupported;
-    auto f = get_program_state().kernel_descriptor(reinterpret_cast<std::uintptr_t>(kernel),
-                                                   target_agent(0));
-
-    return hipModuleOccupancyMaxPotentialBlockSize(gridSize, blockSize, f,
-                                      dynSharedMemPerBlk, blockSizeLimit);
-}
-
-template <typename... Args, typename F = void (*)(Args...)>
-inline
-void hipLaunchKernelGGL(F kernel, const dim3& numBlocks, const dim3& dimBlocks,
-                        std::uint32_t sharedMemBytes, hipStream_t stream,
-                        Args... args) {
-    hip_impl::hip_init();
-    auto kernarg = hip_impl::make_kernarg(kernel, std::tuple<Args...>{std::move(args)...});
-    std::size_t kernarg_size = kernarg.size();
-
-    void* config[]{
-        HIP_LAUNCH_PARAM_BUFFER_POINTER,
-        kernarg.data(),
-        HIP_LAUNCH_PARAM_BUFFER_SIZE,
-        &kernarg_size,
-        HIP_LAUNCH_PARAM_END};
-
-    hip_impl::hipLaunchKernelGGLImpl(reinterpret_cast<std::uintptr_t>(kernel),
-                                     numBlocks, dimBlocks, sharedMemBytes,
-                                     stream, &config[0]);
-}
-
-template <typename F>
-inline
-__attribute__((visibility("hidden")))
-hipError_t hipLaunchCooperativeKernel(F f, dim3 gridDim, dim3 blockDim,
-                                      void** args, size_t sharedMem,
-                                      hipStream_t stream) {
-    hip_impl::hip_init();
-    auto& ps = hip_impl::get_program_state();
-    return hipLaunchCooperativeKernel(reinterpret_cast<void*>(f), gridDim,
-                                      blockDim, args, sharedMem, stream, ps);
-}
-
-inline
-__attribute__((visibility("hidden")))
-hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,
-                                                 int  numDevices,
-                                                 unsigned int  flags) {
-
-    hip_impl::hip_init();
-    auto& ps = hip_impl::get_program_state();
-    return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags, ps);
-}
-
-#pragma GCC visibility pop

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

@@ -1,67 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-#include <hc_defines.h>
-
-#define GRID_LAUNCH_VERSION 20
-
-// Extern definitions
-namespace hc{
-class completion_future;
-class accelerator_view;
-}
-
-
-// 3 dim structure for groups and grids.
-typedef struct gl_dim3
-{
-  int x,y,z;
-  gl_dim3(uint32_t _x=1, uint32_t _y=1, uint32_t _z=1) : x(_x), y(_y), z(_z) {};
-} gl_dim3;
-
-typedef enum gl_barrier_bit {
-    barrier_bit_queue_default,
-    barrier_bit_none,
-    barrier_bit_wait,
-} gl_barrier_bit;
-
-
-// grid_launch_parm contains information used to launch the kernel.
-typedef struct grid_launch_parm
-{
-  //! Grid dimensions
-  gl_dim3      grid_dim;
-
-  //! Group dimensions
-  gl_dim3      group_dim;
-
-  //! Amount of dynamic group memory to use with the kernel launch.
-  //! This memory is in addition to the amount used statically in the kernel.
-  unsigned int  dynamic_group_mem_bytes;
-
-  //! Control setting of barrier bit on per-packet basis:
-  //! See gl_barrier_bit description.  
-  //! Placeholder, is not used to control packet dispatch yet
-  enum gl_barrier_bit barrier_bit;
-
-  //! Value of packet fences to apply to launch.
-  //! The correspond to the value of bits 9:14 in the AQL packet,
-  //! see HSA_PACKET_HEADER_ACQUIRE_FENCE_SCOPE and hsa_fence_scope_t.
-  unsigned int  launch_fence;
-
-  //! Pointer to the accelerator_view where the kernel should execute.
-  //! If NULL, the default view on the default accelerator is used.
-  hc::accelerator_view  *av;
-
-  //! Pointer to the completion_future used to track the status of the command.
-  //! If NULL, the command does not write status.  In this case, 
-  //! synchronization can be enforced with queue-level waits or 
-  //! waiting on younger commands.
-  hc::completion_future *cf;
-
-  grid_launch_parm() = default;
-} grid_launch_parm;
-
-
-extern void init_grid_launch(grid_launch_parm *gl);

triton/backends/amd/include/hip/amd_detail/grid_launch.hpp

@@ -1,50 +0,0 @@
-#pragma once
-
-#include "grid_launch.h"
-#include "hc.hpp"
-
-class grid_launch_parm_cxx : public grid_launch_parm
-{
-public:
-  grid_launch_parm_cxx() = default;
-
-  // customized serialization: don't need av and cf in kernel
-  __attribute__((annotate("serialize")))
-  void __cxxamp_serialize(Kalmar::Serialize& s) const {
-    s.Append(sizeof(int), &grid_dim.x);
-    s.Append(sizeof(int), &grid_dim.y);
-    s.Append(sizeof(int), &grid_dim.z);
-    s.Append(sizeof(int), &group_dim.x);
-    s.Append(sizeof(int), &group_dim.y);
-    s.Append(sizeof(int), &group_dim.z);
-  }
-
-  __attribute__((annotate("user_deserialize")))
-  grid_launch_parm_cxx(int grid_dim_x,  int grid_dim_y,  int grid_dim_z,
-                   int group_dim_x, int group_dim_y, int group_dim_z) {
-    grid_dim.x  = grid_dim_x;
-    grid_dim.y  = grid_dim_y;
-    grid_dim.z  = grid_dim_z;
-    group_dim.x = group_dim_x;
-    group_dim.y = group_dim_y;
-    group_dim.z = group_dim_z;
-  }
-};
-
-
-extern inline void grid_launch_init(grid_launch_parm *lp) {
-  lp->grid_dim.x = lp->grid_dim.y = lp->grid_dim.z = 1;
-
-  lp->group_dim.x = lp->group_dim.y = lp->group_dim.z = 1;
-
-  lp->dynamic_group_mem_bytes = 0;
-
-  lp->barrier_bit = barrier_bit_queue_default;
-  lp->launch_fence = -1;
-
-  // TODO - set to NULL?
-  static hc::accelerator_view av = hc::accelerator().get_default_view();
-  lp->av = &av;
-  lp->cf = NULL;
-}
-

triton/backends/amd/include/hip/amd_detail/grid_launch_GGL.hpp

@@ -1,26 +0,0 @@
-/*
-Copyright (c) 2015 - 2021 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
-
-#if GENERIC_GRID_LAUNCH == 1
-#include "macro_based_grid_launch.hpp"
-#endif  // GENERIC_GRID_LAUNCH

triton/backends/amd/include/hip/amd_detail/helpers.hpp

@@ -1,137 +0,0 @@
-/*
-Copyright (c) 2015 - 2021 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
-#include "concepts.hpp"
-
-#include <type_traits>  // For std::conditional, std::decay, std::enable_if,
-                        // std::false_type, std result_of and std::true_type.
-#include <utility>      // For std::declval.
-
-#ifdef __has_include                      // Check if __has_include is present
-#  if __has_include(<version>)            // Check for version header
-#    include <version>
-#    if defined(__cpp_lib_is_invocable) && !defined(HIP_HAS_INVOCABLE)
-#       define HIP_HAS_INVOCABLE __cpp_lib_is_invocable
-#    endif
-#    if defined(__cpp_lib_result_of_sfinae) && !defined(HIP_HAS_RESULT_OF_SFINAE)
-#       define HIP_HAS_RESULT_OF_SFINAE __cpp_lib_result_of_sfinae
-#    endif
-#  endif
-#endif
-
-#ifndef HIP_HAS_INVOCABLE
-#define HIP_HAS_INVOCABLE 0
-#endif
-
-#ifndef HIP_HAS_RESULT_OF_SFINAE
-#define HIP_HAS_RESULT_OF_SFINAE 0
-#endif
-
-namespace std {  // TODO: these should be removed as soon as possible.
-#if (__cplusplus < 201406L)
-#if (__cplusplus < 201402L)
-template <bool cond, typename T = void>
-using enable_if_t = typename enable_if<cond, T>::type;
-template <bool cond, typename T, typename U>
-using conditional_t = typename conditional<cond, T, U>::type;
-template <typename T>
-using decay_t = typename decay<T>::type;
-template <FunctionalProcedure F, typename... Ts>
-using result_of_t = typename result_of<F(Ts...)>::type;
-template <typename T>
-using remove_reference_t = typename remove_reference<T>::type;
-#endif
-#endif
-}  // namespace std
-
-namespace hip_impl {
-template <typename...>
-using void_t_ = void;
-
-#if HIP_HAS_INVOCABLE
-template <typename, typename = void>
-struct is_callable_impl;
-
-template <FunctionalProcedure F, typename... Ts>
-struct is_callable_impl<F(Ts...)> : std::is_invocable<F, Ts...> {};
-#elif HIP_HAS_RESULT_OF_SFINAE
-template <typename, typename = void>
-struct is_callable_impl : std::false_type {};
-
-template <FunctionalProcedure F, typename... Ts>
-struct is_callable_impl<F(Ts...), void_t_<typename std::result_of<F(Ts...)>::type > > : std::true_type {};
-#else
-template <class Base, class T, class Derived>
-auto simple_invoke(T Base::*pmd, Derived&& ref)
--> decltype(static_cast<Derived&&>(ref).*pmd);
- 
-template <class PMD, class Pointer>
-auto simple_invoke(PMD&& pmd, Pointer&& ptr)
--> decltype((*static_cast<Pointer&&>(ptr)).*static_cast<PMD&&>(pmd));
-
-template <class Base, class T, class Derived>
-auto simple_invoke(T Base::*pmd, const std::reference_wrapper<Derived>& ref)
--> decltype(ref.get().*pmd);
- 
-template <class Base, class T, class Derived, class... Args>
-auto simple_invoke(T Base::*pmf, Derived&& ref, Args&&... args)
--> decltype((static_cast<Derived&&>(ref).*pmf)(static_cast<Args&&>(args)...));
- 
-template <class PMF, class Pointer, class... Args>
-auto simple_invoke(PMF&& pmf, Pointer&& ptr, Args&&... args)
--> decltype(((*static_cast<Pointer&&>(ptr)).*static_cast<PMF&&>(pmf))(static_cast<Args&&>(args)...));
-
-template <class Base, class T, class Derived, class... Args>
-auto simple_invoke(T Base::*pmf, const std::reference_wrapper<Derived>& ref, Args&&... args)
--> decltype((ref.get().*pmf)(static_cast<Args&&>(args)...));
-
-template<class F, class... Ts>
-auto simple_invoke(F&& f, Ts&&... xs) 
--> decltype(f(static_cast<Ts&&>(xs)...));
-
-template <typename, typename = void>
-struct is_callable_impl : std::false_type {};
-
-template <FunctionalProcedure F, typename... Ts>
-struct is_callable_impl<F(Ts...), void_t_<decltype(simple_invoke(std::declval<F>(), std::declval<Ts>()...))> >
-    : std::true_type {};
-
-#endif
-
-template <typename Call>
-struct is_callable : is_callable_impl<Call> {};
-
-#define count_macro_args_impl_hip_(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13,     \
-                                   _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25,     \
-                                   _26, _27, _28, _29, _30, _31, _n, ...)                          \
-    _n
-#define count_macro_args_hip_(...)                                                                 \
-    count_macro_args_impl_hip_(, ##__VA_ARGS__, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20,    \
-                               19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,  \
-                               0)
-
-#define overloaded_macro_expand_hip_(macro, arg_cnt) macro##arg_cnt
-#define overload_macro_impl_hip_(macro, arg_cnt) overloaded_macro_expand_hip_(macro, arg_cnt)
-#define overload_macro_hip_(macro, ...)                                                            \
-    overload_macro_impl_hip_(macro, count_macro_args_hip_(__VA_ARGS__))(__VA_ARGS__)
-}  // namespace hip_impl