/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipcub/checkouts/docs-5.5.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.5.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-2020, 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  return hipCUDAErrorTohipError(

60  ::cub::DeviceSelect::Flagged(

61  d_temp_storage, temp_storage_bytes,

62  d_in, d_flags,

63  d_out, d_num_selected_out, num_items,

64  stream, debug_synchronous

65  )

66  );

67  }

68 

69  template <

70  typename InputIteratorT,

71  typename OutputIteratorT,

72  typename NumSelectedIteratorT,

73  typename SelectOp

74  >

75  HIPCUB_RUNTIME_FUNCTION static

76  hipError_t If(void *d_temp_storage,

77  size_t &temp_storage_bytes,

78  InputIteratorT d_in,

79  OutputIteratorT d_out,

80  NumSelectedIteratorT d_num_selected_out,

81  int num_items,

82  SelectOp select_op,

83  hipStream_t stream = 0,

84  bool debug_synchronous = false)

85  {

86  return hipCUDAErrorTohipError(

87  ::cub::DeviceSelect::If(

88  d_temp_storage, temp_storage_bytes,

89  d_in, d_out, d_num_selected_out,

90  num_items, select_op,

91  stream, debug_synchronous

92  )

93  );

94  }

95 

96  template <

97  typename InputIteratorT,

98  typename OutputIteratorT,

99  typename NumSelectedIteratorT

100  >

101  HIPCUB_RUNTIME_FUNCTION static

102  hipError_t Unique(void *d_temp_storage,

103  size_t &temp_storage_bytes,

104  InputIteratorT d_in,

105  OutputIteratorT d_out,

106  NumSelectedIteratorT d_num_selected_out,

107  int num_items,

108  hipStream_t stream = 0,

109  bool debug_synchronous = false)

110  {

111  return hipCUDAErrorTohipError(

112  ::cub::DeviceSelect::Unique(

113  d_temp_storage, temp_storage_bytes,

114  d_in, d_out, d_num_selected_out, num_items,

115  stream, debug_synchronous

116  )

117  );

118  }

119 

120  template <

121  typename KeyIteratorT,

122  typename ValueIteratorT,

123  typename OutputKeyIteratorT,

124  typename OutputValueIteratorT,

125  typename NumSelectedIteratorT

126  >

127  HIPCUB_RUNTIME_FUNCTION static

128  hipError_t UniqueByKey(void *d_temp_storage,

129  size_t &temp_storage_bytes,

130  KeyIteratorT d_keys_input,

131  ValueIteratorT d_values_input,

132  OutputKeyIteratorT d_keys_output,

133  OutputValueIteratorT d_values_output,

134  NumSelectedIteratorT d_num_selected_out,

135  int num_items,

136  hipStream_t stream = 0,

137  bool debug_synchronous = false)

138  {

139  return hipCUDAErrorTohipError(

140  ::cub::DeviceSelect::UniqueByKey(

141  d_temp_storage, temp_storage_bytes,

142  d_keys_input, d_values_input,

143  d_keys_output, d_values_output,

144  d_num_selected_out, num_items,

145  stream, debug_synchronous

146  )

147  );

148  }

149 };

150 

151 END_HIPCUB_NAMESPACE

152 

153 #endif // HIPCUB_CUB_DEVICE_DEVICE_SELECT_HPP_

hipcub::DeviceSelect

Definition: device_select.hpp:40

hipcub::If

Definition: util_type.hpp:54