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

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

device_partition.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_PARTITION_HPP_

31 #define HIPCUB_CUB_DEVICE_DEVICE_PARTITION_HPP_

32 

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

34 

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

36 

37 BEGIN_HIPCUB_NAMESPACE

38 

39 struct DevicePartition

40 {

41  template <

42  typename InputIteratorT,

43  typename FlagIterator,

44  typename OutputIteratorT,

45  typename NumSelectedIteratorT>

46  HIPCUB_RUNTIME_FUNCTION __forceinline__

47  static hipError_t Flagged(

48  void* d_temp_storage,

49  size_t &temp_storage_bytes,

50  InputIteratorT d_in,

51  FlagIterator d_flags,

52  OutputIteratorT d_out,

53  NumSelectedIteratorT d_num_selected_out,

54  int num_items,

55  hipStream_t stream = 0,

56  bool debug_synchronous = false)

57  {

58  (void)debug_synchronous;

59  return hipCUDAErrorTohipError(::cub::DevicePartition::Flagged(d_temp_storage,

60  temp_storage_bytes,

61  d_in,

62  d_flags,

63  d_out,

64  d_num_selected_out,

65  num_items,

66  stream));

67  }

68 

69  template <

70  typename InputIteratorT,

71  typename OutputIteratorT,

72  typename NumSelectedIteratorT,

73  typename SelectOp>

74  HIPCUB_RUNTIME_FUNCTION __forceinline__

75  static hipError_t If(

76  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  (void)debug_synchronous;

87  return hipCUDAErrorTohipError(::cub::DevicePartition::If(d_temp_storage,

88  temp_storage_bytes,

89  d_in,

90  d_out,

91  d_num_selected_out,

92  num_items,

93  select_op,

94  stream));

95  }

96 

97  template <typename InputIteratorT,

98  typename FirstOutputIteratorT,

99  typename SecondOutputIteratorT,

100  typename UnselectedOutputIteratorT,

101  typename NumSelectedIteratorT,

102  typename SelectFirstPartOp,

103  typename SelectSecondPartOp>

104  HIPCUB_RUNTIME_FUNCTION __forceinline__ static hipError_t

105  If(void *d_temp_storage,

106  std::size_t &temp_storage_bytes,

107  InputIteratorT d_in,

108  FirstOutputIteratorT d_first_part_out,

109  SecondOutputIteratorT d_second_part_out,

110  UnselectedOutputIteratorT d_unselected_out,

111  NumSelectedIteratorT d_num_selected_out,

112  int num_items,

113  SelectFirstPartOp select_first_part_op,

114  SelectSecondPartOp select_second_part_op,

115  hipStream_t stream = 0,

116  bool debug_synchronous = false)

117  {

118  (void)debug_synchronous;

119  return hipCUDAErrorTohipError(::cub::DevicePartition::If(d_temp_storage,

120  temp_storage_bytes,

121  d_in,

122  d_first_part_out,

123  d_second_part_out,

124  d_unselected_out,

125  d_num_selected_out,

126  num_items,

127  select_first_part_op,

128  select_second_part_op,

129  stream));

130  }

131 };

132 

133 END_HIPCUB_NAMESPACE

134 

135 #endif // HIPCUB_CUB_DEVICE_DEVICE_PARTITION_HPP_

hipcub::DevicePartition

Definition: device_partition.hpp:40

hipcub::DevicePartition::If

__host__ static __forceinline__ hipError_t If(void *d_temp_storage, size_t &temp_storage_bytes, InputIteratorT d_in, OutputIteratorT d_out, NumSelectedIteratorT d_num_selected_out, int num_items, SelectOp select_op, hipStream_t stream=0, bool debug_synchronous=false)

Definition: device_partition.hpp:75

hipcub::DevicePartition::Flagged

__host__ static __forceinline__ hipError_t Flagged(void *d_temp_storage, size_t &temp_storage_bytes, InputIteratorT d_in, FlagIterator d_flags, OutputIteratorT d_out, NumSelectedIteratorT d_num_selected_out, int num_items, hipStream_t stream=0, bool debug_synchronous=false)

Definition: device_partition.hpp:47

hipcub::If

Definition: util_type.hpp:54