/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipcub/checkouts/docs-5.7.1/hipcub/include/hipcub/backend/cub/device/device_reduce.hpp Source File

• home
• docs
• checkouts
• readthedocs.org
• user_builds
• advanced-micro-devices-hipcub
• checkouts
• docs-5.7.1
• hipcub
• include
• hipcub
• backend
• cub
• device

device_reduce.hpp

1 /******************************************************************************

2  * Copyright (c) 2010-2011, Duane Merrill. All rights reserved.

3  * Copyright (c) 2011-2018, NVIDIA CORPORATION. All rights reserved.

4  * Modifications Copyright (c) 2017-2023, Advanced Micro Devices, Inc. All rights reserved.

5  *

6  * Redistribution and use in source and binary forms, with or without

7  * modification, are permitted provided that the following conditions are met:

8  * * Redistributions of source code must retain the above copyright

9  * notice, this list of conditions and the following disclaimer.

10  * * Redistributions in binary form must reproduce the above copyright

11  * notice, this list of conditions and the following disclaimer in the

12  * documentation and/or other materials provided with the distribution.

13  * * Neither the name of the NVIDIA CORPORATION nor the

14  * names of its contributors may be used to endorse or promote products

15  * derived from this software without specific prior written permission.

16  *

17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

20  * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY

21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

26  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

27  *

28  ******************************************************************************/

29 

30 #ifndef HIPCUB_CUB_DEVICE_DEVICE_REDUCE_HPP_

31 #define HIPCUB_CUB_DEVICE_DEVICE_REDUCE_HPP_

32 

33 #include "../../../config.hpp"

34 

35 #include <cub/device/device_reduce.cuh>

36 

37 BEGIN_HIPCUB_NAMESPACE

38 

39 class DeviceReduce

40 {

41 public:

42  template <

43  typename InputIteratorT,

44  typename OutputIteratorT,

45  typename ReduceOpT,

46  typename T

47  >

48  HIPCUB_RUNTIME_FUNCTION static

49  hipError_t Reduce(void *d_temp_storage,

50  size_t &temp_storage_bytes,

51  InputIteratorT d_in,

52  OutputIteratorT d_out,

53  int num_items,

54  ReduceOpT reduction_op,

55  T init,

56  hipStream_t stream = 0,

57  bool debug_synchronous = false)

58  {

59  (void)debug_synchronous;

60  return hipCUDAErrorTohipError(::cub::DeviceReduce::Reduce(d_temp_storage,

61  temp_storage_bytes,

62  d_in,

63  d_out,

64  num_items,

65  reduction_op,

66  init,

67  stream));

68  }

69 

70  template <

71  typename InputIteratorT,

72  typename OutputIteratorT

73  >

74  HIPCUB_RUNTIME_FUNCTION static

75  hipError_t Sum(void *d_temp_storage,

76  size_t &temp_storage_bytes,

77  InputIteratorT d_in,

78  OutputIteratorT d_out,

79  int num_items,

80  hipStream_t stream = 0,

81  bool debug_synchronous = false)

82  {

83  (void)debug_synchronous;

84  return hipCUDAErrorTohipError(::cub::DeviceReduce::Sum(d_temp_storage,

85  temp_storage_bytes,

86  d_in,

87  d_out,

88  num_items,

89  stream));

90  }

91 

92  template <

93  typename InputIteratorT,

94  typename OutputIteratorT

95  >

96  HIPCUB_RUNTIME_FUNCTION static

97  hipError_t Min(void *d_temp_storage,

98  size_t &temp_storage_bytes,

99  InputIteratorT d_in,

100  OutputIteratorT d_out,

101  int num_items,

102  hipStream_t stream = 0,

103  bool debug_synchronous = false)

104  {

105  (void)debug_synchronous;

106  return hipCUDAErrorTohipError(::cub::DeviceReduce::Min(d_temp_storage,

107  temp_storage_bytes,

108  d_in,

109  d_out,

110  num_items,

111  stream));

112  }

113 

114  template <

115  typename InputIteratorT,

116  typename OutputIteratorT

117  >

118  HIPCUB_RUNTIME_FUNCTION static

119  hipError_t ArgMin(void *d_temp_storage,

120  size_t &temp_storage_bytes,

121  InputIteratorT d_in,

122  OutputIteratorT d_out,

123  int num_items,

124  hipStream_t stream = 0,

125  bool debug_synchronous = false)

126  {

127  (void)debug_synchronous;

128  return hipCUDAErrorTohipError(::cub::DeviceReduce::ArgMin(d_temp_storage,

129  temp_storage_bytes,

130  d_in,

131  d_out,

132  num_items,

133  stream));

134  }

135 

136  template <

137  typename InputIteratorT,

138  typename OutputIteratorT

139  >

140  HIPCUB_RUNTIME_FUNCTION static

141  hipError_t Max(void *d_temp_storage,

142  size_t &temp_storage_bytes,

143  InputIteratorT d_in,

144  OutputIteratorT d_out,

145  int num_items,

146  hipStream_t stream = 0,

147  bool debug_synchronous = false)

148  {

149  (void)debug_synchronous;

150  return hipCUDAErrorTohipError(::cub::DeviceReduce::Max(d_temp_storage,

151  temp_storage_bytes,

152  d_in,

153  d_out,

154  num_items,

155  stream));

156  }

157 

158  template <

159  typename InputIteratorT,

160  typename OutputIteratorT

161  >

162  HIPCUB_RUNTIME_FUNCTION static

163  hipError_t ArgMax(void *d_temp_storage,

164  size_t &temp_storage_bytes,

165  InputIteratorT d_in,

166  OutputIteratorT d_out,

167  int num_items,

168  hipStream_t stream = 0,

169  bool debug_synchronous = false)

170  {

171  (void)debug_synchronous;

172  return hipCUDAErrorTohipError(::cub::DeviceReduce::ArgMax(d_temp_storage,

173  temp_storage_bytes,

174  d_in,

175  d_out,

176  num_items,

177  stream));

178  }

179 

180  template<

181  typename KeysInputIteratorT,

182  typename UniqueOutputIteratorT,

183  typename ValuesInputIteratorT,

184  typename AggregatesOutputIteratorT,

185  typename NumRunsOutputIteratorT,

186  typename ReductionOpT

187  >

188  HIPCUB_RUNTIME_FUNCTION static

189  hipError_t ReduceByKey(void * d_temp_storage,

190  size_t& temp_storage_bytes,

191  KeysInputIteratorT d_keys_in,

192  UniqueOutputIteratorT d_unique_out,

193  ValuesInputIteratorT d_values_in,

194  AggregatesOutputIteratorT d_aggregates_out,

195  NumRunsOutputIteratorT d_num_runs_out,

196  ReductionOpT reduction_op,

197  int num_items,

198  hipStream_t stream = 0,

199  bool debug_synchronous = false)

200  {

201  (void)debug_synchronous;

202  return hipCUDAErrorTohipError(::cub::DeviceReduce::ReduceByKey(d_temp_storage,

203  temp_storage_bytes,

204  d_keys_in,

205  d_unique_out,

206  d_values_in,

207  d_aggregates_out,

208  d_num_runs_out,

209  reduction_op,

210  num_items,

211  stream));

212  }

213 };

214 

215 END_HIPCUB_NAMESPACE

216 

217 #endif // HIPCUB_CUB_DEVICE_DEVICE_REDUCE_HPP_

hipcub::DeviceReduce

Definition: device_reduce.hpp:40

hipcub::ArgMax

Definition: thread_operators.hpp:126

hipcub::ArgMin

Definition: thread_operators.hpp:141

hipcub::Max

Definition: thread_operators.hpp:106

hipcub::Min

Definition: thread_operators.hpp:116

hipcub::Sum

Definition: thread_operators.hpp:76