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

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

device_segmented_sort.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_SEGMENTED_SORT_HPP_

31 #define HIPCUB_CUB_DEVICE_DEVICE_SEGMENTED_SORT_HPP_

32 

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

34 

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

36 

37 BEGIN_HIPCUB_NAMESPACE

38 

39 struct DeviceSegmentedSort

40 {

41  template <typename KeyT,

42  typename BeginOffsetIteratorT,

43  typename EndOffsetIteratorT>

44  HIPCUB_RUNTIME_FUNCTION static

45  hipError_t SortKeys(void * d_temp_storage,

46  size_t& temp_storage_bytes,

47  const KeyT * d_keys_in,

48  KeyT * d_keys_out,

49  int num_items,

50  int num_segments,

51  BeginOffsetIteratorT d_begin_offsets,

52  EndOffsetIteratorT d_end_offsets,

53  hipStream_t stream = 0,

54  bool debug_synchronous = false)

55  {

56  return hipCUDAErrorTohipError(

57  ::cub::DeviceSegmentedSort::SortKeys(

58  d_temp_storage, temp_storage_bytes,

59  d_keys_in, d_keys_out,

60  num_items, num_segments,

61  d_begin_offsets, d_end_offsets,

62  stream, debug_synchronous

63  )

64  );

65  }

66 

67  template <typename KeyT,

68  typename BeginOffsetIteratorT,

69  typename EndOffsetIteratorT>

70  HIPCUB_RUNTIME_FUNCTION static

71  hipError_t SortKeysDescending(void * d_temp_storage,

72  size_t& temp_storage_bytes,

73  const KeyT * d_keys_in,

74  KeyT * d_keys_out,

75  int num_items,

76  int num_segments,

77  BeginOffsetIteratorT d_begin_offsets,

78  EndOffsetIteratorT d_end_offsets,

79  hipStream_t stream = 0,

80  bool debug_synchronous = false)

81  {

82  return hipCUDAErrorTohipError(

83  ::cub::DeviceSegmentedSort::SortKeysDescending(

84  d_temp_storage, temp_storage_bytes,

85  d_keys_in, d_keys_out,

86  num_items, num_segments,

87  d_begin_offsets, d_end_offsets,

88  stream, debug_synchronous

89  )

90  );

91  }

92 

93  template <typename KeyT,

94  typename BeginOffsetIteratorT,

95  typename EndOffsetIteratorT>

96  HIPCUB_RUNTIME_FUNCTION static

97  hipError_t SortKeys(void * d_temp_storage,

98  size_t& temp_storage_bytes,

99  DoubleBuffer<KeyT> &d_keys,

100  int num_items,

101  int num_segments,

102  BeginOffsetIteratorT d_begin_offsets,

103  EndOffsetIteratorT d_end_offsets,

104  hipStream_t stream = 0,

105  bool debug_synchronous = false)

106  {

107  return hipCUDAErrorTohipError(

108  ::cub::DeviceSegmentedSort::SortKeys(

109  d_temp_storage, temp_storage_bytes,

110  d_keys,

111  num_items, num_segments,

112  d_begin_offsets, d_end_offsets,

113  stream, debug_synchronous

114  )

115  );

116  }

117 

118  template <typename KeyT,

119  typename BeginOffsetIteratorT,

120  typename EndOffsetIteratorT>

121  HIPCUB_RUNTIME_FUNCTION static

122  hipError_t SortKeysDescending(void * d_temp_storage,

123  size_t& temp_storage_bytes,

124  DoubleBuffer<KeyT> &d_keys,

125  int num_items,

126  int num_segments,

127  BeginOffsetIteratorT d_begin_offsets,

128  EndOffsetIteratorT d_end_offsets,

129  hipStream_t stream = 0,

130  bool debug_synchronous = false)

131  {

132  return hipCUDAErrorTohipError(

133  ::cub::DeviceSegmentedSort::SortKeysDescending(

134  d_temp_storage, temp_storage_bytes,

135  d_keys,

136  num_items, num_segments,

137  d_begin_offsets, d_end_offsets,

138  stream, debug_synchronous

139  )

140  );

141  }

142 

143  template <typename KeyT,

144  typename BeginOffsetIteratorT,

145  typename EndOffsetIteratorT>

146  HIPCUB_RUNTIME_FUNCTION static

147  hipError_t StableSortKeys(void * d_temp_storage,

148  size_t& temp_storage_bytes,

149  const KeyT * d_keys_in,

150  KeyT * d_keys_out,

151  int num_items,

152  int num_segments,

153  BeginOffsetIteratorT d_begin_offsets,

154  EndOffsetIteratorT d_end_offsets,

155  hipStream_t stream = 0,

156  bool debug_synchronous = false)

157  {

158  return hipCUDAErrorTohipError(

159  ::cub::DeviceSegmentedSort::StableSortKeys(

160  d_temp_storage, temp_storage_bytes,

161  d_keys_in, d_keys_out,

162  num_items, num_segments,

163  d_begin_offsets, d_end_offsets,

164  stream, debug_synchronous

165  )

166  );

167  }

168 

169  template <typename KeyT,

170  typename BeginOffsetIteratorT,

171  typename EndOffsetIteratorT>

172  HIPCUB_RUNTIME_FUNCTION static

173  hipError_t StableSortKeysDescending(void * d_temp_storage,

174  size_t& temp_storage_bytes,

175  const KeyT * d_keys_in,

176  KeyT * d_keys_out,

177  int num_items,

178  int num_segments,

179  BeginOffsetIteratorT d_begin_offsets,

180  EndOffsetIteratorT d_end_offsets,

181  hipStream_t stream = 0,

182  bool debug_synchronous = false)

183  {

184  return hipCUDAErrorTohipError(

185  ::cub::DeviceSegmentedSort::StableSortKeysDescending(

186  d_temp_storage, temp_storage_bytes,

187  d_keys_in, d_keys_out,

188  num_items, num_segments,

189  d_begin_offsets, d_end_offsets,

190  stream, debug_synchronous

191  )

192  );

193  }

194 

195  template <typename KeyT,

196  typename BeginOffsetIteratorT,

197  typename EndOffsetIteratorT>

198  HIPCUB_RUNTIME_FUNCTION static

199  hipError_t StableSortKeys(void * d_temp_storage,

200  size_t& temp_storage_bytes,

201  DoubleBuffer<KeyT> &d_keys,

202  int num_items,

203  int num_segments,

204  BeginOffsetIteratorT d_begin_offsets,

205  EndOffsetIteratorT d_end_offsets,

206  hipStream_t stream = 0,

207  bool debug_synchronous = false)

208  {

209  return hipCUDAErrorTohipError(

210  ::cub::DeviceSegmentedSort::StableSortKeys(

211  d_temp_storage, temp_storage_bytes,

212  d_keys,

213  num_items, num_segments,

214  d_begin_offsets, d_end_offsets,

215  stream, debug_synchronous

216  )

217  );

218  }

219 

220  template <typename KeyT,

221  typename BeginOffsetIteratorT,

222  typename EndOffsetIteratorT>

223  HIPCUB_RUNTIME_FUNCTION static

224  hipError_t StableSortKeysDescending(void * d_temp_storage,

225  size_t& temp_storage_bytes,

226  DoubleBuffer<KeyT> &d_keys,

227  int num_items,

228  int num_segments,

229  BeginOffsetIteratorT d_begin_offsets,

230  EndOffsetIteratorT d_end_offsets,

231  hipStream_t stream = 0,

232  bool debug_synchronous = false)

233  {

234  return hipCUDAErrorTohipError(

235  ::cub::DeviceSegmentedSort::StableSortKeysDescending(

236  d_temp_storage, temp_storage_bytes,

237  d_keys,

238  num_items, num_segments,

239  d_begin_offsets, d_end_offsets,

240  stream, debug_synchronous

241  )

242  );

243  }

244 

245  template <typename KeyT,

246  typename ValueT,

247  typename BeginOffsetIteratorT,

248  typename EndOffsetIteratorT>

249  HIPCUB_RUNTIME_FUNCTION static

250  hipError_t SortPairs(void * d_temp_storage,

251  size_t& temp_storage_bytes,

252  const KeyT * d_keys_in,

253  KeyT * d_keys_out,

254  const ValueT * d_values_in,

255  ValueT * d_values_out,

256  int num_items,

257  int num_segments,

258  BeginOffsetIteratorT d_begin_offsets,

259  EndOffsetIteratorT d_end_offsets,

260  hipStream_t stream = 0,

261  bool debug_synchronous = false)

262  {

263  return hipCUDAErrorTohipError(

264  ::cub::DeviceSegmentedSort::SortPairs(

265  d_temp_storage, temp_storage_bytes,

266  d_keys_in, d_keys_out,

267  d_values_in, d_values_out,

268  num_items, num_segments,

269  d_begin_offsets, d_end_offsets,

270  stream, debug_synchronous

271  )

272  );

273  }

274 

275  template <typename KeyT,

276  typename ValueT,

277  typename BeginOffsetIteratorT,

278  typename EndOffsetIteratorT>

279  HIPCUB_RUNTIME_FUNCTION static

280  hipError_t SortPairsDescending(void * d_temp_storage,

281  size_t& temp_storage_bytes,

282  const KeyT * d_keys_in,

283  KeyT * d_keys_out,

284  const ValueT * d_values_in,

285  ValueT * d_values_out,

286  int num_items,

287  int num_segments,

288  BeginOffsetIteratorT d_begin_offsets,

289  EndOffsetIteratorT d_end_offsets,

290  hipStream_t stream = 0,

291  bool debug_synchronous = false)

292  {

293  return hipCUDAErrorTohipError(

294  ::cub::DeviceSegmentedSort::SortPairsDescending(

295  d_temp_storage, temp_storage_bytes,

296  d_keys_in, d_keys_out,

297  d_values_in, d_values_out,

298  num_items, num_segments,

299  d_begin_offsets, d_end_offsets,

300  stream, debug_synchronous

301  )

302  );

303  }

304 

305  template <typename KeyT,

306  typename ValueT,

307  typename BeginOffsetIteratorT,

308  typename EndOffsetIteratorT>

309  HIPCUB_RUNTIME_FUNCTION static

310  hipError_t SortPairs(void * d_temp_storage,

311  size_t& temp_storage_bytes,

312  DoubleBuffer<KeyT> &d_keys,

313  DoubleBuffer<ValueT> &d_values,

314  int num_items,

315  int num_segments,

316  BeginOffsetIteratorT d_begin_offsets,

317  EndOffsetIteratorT d_end_offsets,

318  hipStream_t stream = 0,

319  bool debug_synchronous = false)

320  {

321  return hipCUDAErrorTohipError(

322  ::cub::DeviceSegmentedSort::SortPairs(

323  d_temp_storage, temp_storage_bytes,

324  d_keys, d_values,

325  num_items, num_segments,

326  d_begin_offsets, d_end_offsets,

327  stream, debug_synchronous

328  )

329  );

330  }

331 

332  template <typename KeyT,

333  typename ValueT,

334  typename BeginOffsetIteratorT,

335  typename EndOffsetIteratorT>

336  HIPCUB_RUNTIME_FUNCTION static

337  hipError_t SortPairsDescending(void * d_temp_storage,

338  size_t& temp_storage_bytes,

339  DoubleBuffer<KeyT> &d_keys,

340  DoubleBuffer<ValueT> &d_values,

341  int num_items,

342  int num_segments,

343  BeginOffsetIteratorT d_begin_offsets,

344  EndOffsetIteratorT d_end_offsets,

345  hipStream_t stream = 0,

346  bool debug_synchronous = false)

347  {

348  return hipCUDAErrorTohipError(

349  ::cub::DeviceSegmentedSort::SortPairsDescending(

350  d_temp_storage, temp_storage_bytes,

351  d_keys, d_values,

352  num_items, num_segments,

353  d_begin_offsets, d_end_offsets,

354  stream, debug_synchronous

355  )

356  );

357  }

358 

359  template <typename KeyT,

360  typename ValueT,

361  typename BeginOffsetIteratorT,

362  typename EndOffsetIteratorT>

363  HIPCUB_RUNTIME_FUNCTION static

364  hipError_t StableSortPairs(void * d_temp_storage,

365  size_t& temp_storage_bytes,

366  const KeyT * d_keys_in,

367  KeyT * d_keys_out,

368  const ValueT * d_values_in,

369  ValueT * d_values_out,

370  int num_items,

371  int num_segments,

372  BeginOffsetIteratorT d_begin_offsets,

373  EndOffsetIteratorT d_end_offsets,

374  hipStream_t stream = 0,

375  bool debug_synchronous = false)

376  {

377  return hipCUDAErrorTohipError(

378  ::cub::DeviceSegmentedSort::StableSortPairs(

379  d_temp_storage, temp_storage_bytes,

380  d_keys_in, d_keys_out,

381  d_values_in, d_values_out,

382  num_items, num_segments,

383  d_begin_offsets, d_end_offsets,

384  stream, debug_synchronous

385  )

386  );

387  }

388 

389  template <typename KeyT,

390  typename ValueT,

391  typename BeginOffsetIteratorT,

392  typename EndOffsetIteratorT>

393  HIPCUB_RUNTIME_FUNCTION static

394  hipError_t StableSortPairsDescending(void * d_temp_storage,

395  size_t& temp_storage_bytes,

396  const KeyT * d_keys_in,

397  KeyT * d_keys_out,

398  const ValueT * d_values_in,

399  ValueT * d_values_out,

400  int num_items,

401  int num_segments,

402  BeginOffsetIteratorT d_begin_offsets,

403  EndOffsetIteratorT d_end_offsets,

404  hipStream_t stream = 0,

405  bool debug_synchronous = false)

406  {

407  return hipCUDAErrorTohipError(

408  ::cub::DeviceSegmentedSort::StableSortPairsDescending(

409  d_temp_storage, temp_storage_bytes,

410  d_keys_in, d_keys_out,

411  d_values_in, d_values_out,

412  num_items, num_segments,

413  d_begin_offsets, d_end_offsets,

414  stream, debug_synchronous

415  )

416  );

417  }

418 

419  template <typename KeyT,

420  typename ValueT,

421  typename BeginOffsetIteratorT,

422  typename EndOffsetIteratorT>

423  HIPCUB_RUNTIME_FUNCTION static

424  hipError_t StableSortPairs(void * d_temp_storage,

425  size_t& temp_storage_bytes,

426  DoubleBuffer<KeyT> &d_keys,

427  DoubleBuffer<ValueT> &d_values,

428  int num_items,

429  int num_segments,

430  BeginOffsetIteratorT d_begin_offsets,

431  EndOffsetIteratorT d_end_offsets,

432  hipStream_t stream = 0,

433  bool debug_synchronous = false)

434  {

435  return hipCUDAErrorTohipError(

436  ::cub::DeviceSegmentedSort::StableSortPairs(

437  d_temp_storage, temp_storage_bytes,

438  d_keys, d_values,

439  num_items, num_segments,

440  d_begin_offsets, d_end_offsets,

441  stream, debug_synchronous

442  )

443  );

444  }

445 

446  template <typename KeyT,

447  typename ValueT,

448  typename BeginOffsetIteratorT,

449  typename EndOffsetIteratorT>

450  HIPCUB_RUNTIME_FUNCTION static

451  hipError_t StableSortPairsDescending(void * d_temp_storage,

452  size_t& temp_storage_bytes,

453  DoubleBuffer<KeyT> &d_keys,

454  DoubleBuffer<ValueT> &d_values,

455  int num_items,

456  int num_segments,

457  BeginOffsetIteratorT d_begin_offsets,

458  EndOffsetIteratorT d_end_offsets,

459  hipStream_t stream = 0,

460  bool debug_synchronous = false)

461  {

462  return hipCUDAErrorTohipError(

463  ::cub::DeviceSegmentedSort::StableSortPairsDescending(

464  d_temp_storage, temp_storage_bytes,

465  d_keys, d_values,

466  num_items, num_segments,

467  d_begin_offsets, d_end_offsets,

468  stream, debug_synchronous

469  )

470  );

471  }

472 };

473 

474 END_HIPCUB_NAMESPACE

475 

476 #endif // HIPCUB_CUB_DEVICE_DEVICE_SEGMENTED_SORT_HPP_

hipcub::DeviceSegmentedSort

Definition: device_segmented_sort.hpp:40

hipcub::DoubleBuffer

Definition: util_type.hpp:108