/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipcub/checkouts/docs-5.7.1/hipcub/include/hipcub/backend/cub/device/device_select.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_select.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_SELECT_HPP_

31 #define HIPCUB_CUB_DEVICE_DEVICE_SELECT_HPP_

32 

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

34 

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

36 

37 BEGIN_HIPCUB_NAMESPACE

38 

39 class DeviceSelect

40 {

41 public:

42  template <

43  typename InputIteratorT,

44  typename FlagIterator,

45  typename OutputIteratorT,

46  typename NumSelectedIteratorT

47  >

48  HIPCUB_RUNTIME_FUNCTION static

49  hipError_t Flagged(void *d_temp_storage,

50  size_t &temp_storage_bytes,

51  InputIteratorT d_in,

52  FlagIterator d_flags,

53  OutputIteratorT d_out,

54  NumSelectedIteratorT d_num_selected_out,

55  int num_items,

56  hipStream_t stream = 0,

57  bool debug_synchronous = false)

58  {

59  (void)debug_synchronous;

60  return hipCUDAErrorTohipError(::cub::DeviceSelect::Flagged(d_temp_storage,

61  temp_storage_bytes,

62  d_in,

63  d_flags,

64  d_out,

65  d_num_selected_out,

66  num_items,

67  stream));

68  }

69 

70  template <

71  typename InputIteratorT,

72  typename OutputIteratorT,

73  typename NumSelectedIteratorT,

74  typename SelectOp

75  >

76  HIPCUB_RUNTIME_FUNCTION static

77  hipError_t If(void *d_temp_storage,

78  size_t &temp_storage_bytes,

79  InputIteratorT d_in,

80  OutputIteratorT d_out,

81  NumSelectedIteratorT d_num_selected_out,

82  int num_items,

83  SelectOp select_op,

84  hipStream_t stream = 0,

85  bool debug_synchronous = false)

86  {

87  (void)debug_synchronous;

88  return hipCUDAErrorTohipError(::cub::DeviceSelect::If(d_temp_storage,

89  temp_storage_bytes,

90  d_in,

91  d_out,

92  d_num_selected_out,

93  num_items,

94  select_op,

95  stream));

96  }

97 

98  template <

99  typename InputIteratorT,

100  typename OutputIteratorT,

101  typename NumSelectedIteratorT

102  >

103  HIPCUB_RUNTIME_FUNCTION static

104  hipError_t Unique(void *d_temp_storage,

105  size_t &temp_storage_bytes,

106  InputIteratorT d_in,

107  OutputIteratorT d_out,

108  NumSelectedIteratorT d_num_selected_out,

109  int num_items,

110  hipStream_t stream = 0,

111  bool debug_synchronous = false)

112  {

113  (void)debug_synchronous;

114  return hipCUDAErrorTohipError(::cub::DeviceSelect::Unique(d_temp_storage,

115  temp_storage_bytes,

116  d_in,

117  d_out,

118  d_num_selected_out,

119  num_items,

120  stream));

121  }

122 

123  template <

124  typename KeyIteratorT,

125  typename ValueIteratorT,

126  typename OutputKeyIteratorT,

127  typename OutputValueIteratorT,

128  typename NumSelectedIteratorT

129  >

130  HIPCUB_RUNTIME_FUNCTION static

131  hipError_t UniqueByKey(void *d_temp_storage,

132  size_t &temp_storage_bytes,

133  KeyIteratorT d_keys_input,

134  ValueIteratorT d_values_input,

135  OutputKeyIteratorT d_keys_output,

136  OutputValueIteratorT d_values_output,

137  NumSelectedIteratorT d_num_selected_out,

138  int num_items,

139  hipStream_t stream = 0,

140  bool debug_synchronous = false)

141  {

142  (void)debug_synchronous;

143  return hipCUDAErrorTohipError(::cub::DeviceSelect::UniqueByKey(d_temp_storage,

144  temp_storage_bytes,

145  d_keys_input,

146  d_values_input,

147  d_keys_output,

148  d_values_output,

149  d_num_selected_out,

150  num_items,

151  stream));

152  }

153 };

154 

155 END_HIPCUB_NAMESPACE

156 

157 #endif // HIPCUB_CUB_DEVICE_DEVICE_SELECT_HPP_

hipcub::DeviceSelect

Definition: device_select.hpp:40

hipcub::If

Definition: util_type.hpp:54