prenex/magyarsort
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

mormordsort - buggy version (I actually think its some of the Magyarsort 2.x in this form - but needs fixing

Browse Source
This commit is contained in:
Richard Thier 2024-04-11 06:13:51 +02:00
parent 6426560519
commit 55583bcb4a
3 changed files with 204 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

204
magyarsort.h
View File

@ -66,11 +66,11 @@ namespace MagyarSort {
} }
template<typename COUNTER_TYP> template<typename COUNTER_TYP>
void debugRadics(COUNTER_TYP *radics) { void debugRadics(COUNTER_TYP *magics) {
for(size_t j = 0; j < DIGITS; ++j) { for(size_t j = 0; j < DIGITS; ++j) {
printf("d%zu: ", j); printf("d%zu: ", j);
for(int i = 0; i < DIGIT_RANGE; ++i) { for(int i = 0; i < DIGIT_RANGE; ++i) {
printf("%zu,", radics[i + DIGIT_RANGE*j]); printf("%zu,", magics[i + DIGIT_RANGE*j]);
} }
printf("\n\n"); printf("\n\n");
} }
@ -89,16 +89,16 @@ namespace MagyarSort {
/** Recursive Functor: no class should be generated I think (compiler should be smart) */ /** Recursive Functor: no class should be generated I think (compiler should be smart) */
template<int DIGIT, typename COUNTER_TYP> template<int DIGIT, typename COUNTER_TYP>
struct OccurenceMagic : public OccurenceMagic<DIGIT - 1, COUNTER_TYP> { struct OccurenceMagic : public OccurenceMagic<DIGIT - 1, COUNTER_TYP> {
inline __attribute__((always_inline)) OccurenceMagic(uint32_t arr[], COUNTER_TYP i, COUNTER_TYP *radicsOut) noexcept inline __attribute__((always_inline)) OccurenceMagic(uint32_t arr[], COUNTER_TYP i, COUNTER_TYP *magicsOut) noexcept
: OccurenceMagic<DIGIT - 1 ,COUNTER_TYP>(arr, i, radicsOut) { : OccurenceMagic<DIGIT - 1 ,COUNTER_TYP>(arr, i, magicsOut) {
// Parents run first so template recursion runs DIGIT=0 first... // Parents run first so template recursion runs DIGIT=0 first...
++radicsOut[getDigit<DIGIT>(arr[i]) + DIGIT_RANGE * DIGIT]; ++magicsOut[getDigit<DIGIT>(arr[i]) + DIGIT_RANGE * DIGIT];
} }
}; };
/** Ends template recursion */ /** Ends template recursion */
template<typename COUNTER_TYP> template<typename COUNTER_TYP>
struct OccurenceMagic<-1, COUNTER_TYP> { struct OccurenceMagic<-1, COUNTER_TYP> {
inline __attribute__((always_inline)) OccurenceMagic(uint32_t arr[], COUNTER_TYP i, COUNTER_TYP *radicsOut) noexcept {} inline __attribute__((always_inline)) OccurenceMagic(uint32_t arr[], COUNTER_TYP i, COUNTER_TYP *magicsOut) noexcept {}
}; };
/** ARR_END must be an (STEP * k) */ /** ARR_END must be an (STEP * k) */
@ -116,7 +116,7 @@ namespace MagyarSort {
}; };
template<typename COUNTER_TYP> template<typename COUNTER_TYP>
static inline void countOccurences(uint32_t arr[], COUNTER_TYP size, COUNTER_TYP *radicsOut) noexcept { static inline void countOccurences(uint32_t arr[], COUNTER_TYP size, COUNTER_TYP *magicsOut) noexcept {
COUNTER_TYP i = 0; COUNTER_TYP i = 0;
//#pragma GCC unroll 4 //#pragma GCC unroll 4
for(; i < size - 64; i += 64) { for(; i < size - 64; i += 64) {
@ -124,131 +124,131 @@ namespace MagyarSort {
//__builtin_prefetch(&arr[i + (1 * 16)], 0, 2); // r, L2 or L3 cache //__builtin_prefetch(&arr[i + (1 * 16)], 0, 2); // r, L2 or L3 cache
__builtin_prefetch(&arr[i + (1 * 16)]); __builtin_prefetch(&arr[i + (1 * 16)]);
// Creates no object, struct is empty // Creates no object, struct is empty
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 1, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 1, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 2, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 2, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 3, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 3, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 4, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 4, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 5, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 5, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 6, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 6, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 7, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 7, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 8, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 8, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 9, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 9, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 10, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 10, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 11, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 11, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 12, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 12, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 13, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 13, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 14, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 14, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 15, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 15, magicsOut);
// Prefetch for read level-1 cache // Prefetch for read level-1 cache
__builtin_prefetch(&arr[i + (2 * 16)]); __builtin_prefetch(&arr[i + (2 * 16)]);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 16, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 16, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 17, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 17, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 18, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 18, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 19, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 19, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 20, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 20, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 21, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 21, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 22, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 22, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 23, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 23, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 24, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 24, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 25, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 25, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 26, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 26, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 27, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 27, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 28, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 28, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 29, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 29, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 30, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 30, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 31, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 31, magicsOut);
__builtin_prefetch(&arr[i + (3 * 16)]); __builtin_prefetch(&arr[i + (3 * 16)]);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 32, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 32, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 33, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 33, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 34, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 34, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 35, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 35, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 36, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 36, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 37, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 37, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 38, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 38, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 39, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 39, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 40, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 40, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 41, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 41, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 42, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 42, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 43, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 43, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 44, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 44, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 45, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 45, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 46, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 46, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 47, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 47, magicsOut);
// __builtin_prefetch(&arr[i + (4 * 16)]); // Only needed for longer than 64 unrolls // __builtin_prefetch(&arr[i + (4 * 16)]); // Only needed for longer than 64 unrolls
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 48, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 48, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 49, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 49, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 50, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 50, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 51, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 51, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 52, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 52, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 53, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 53, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 54, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 54, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 55, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 55, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 56, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 56, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 57, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 57, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 58, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 58, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 59, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 59, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 60, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 60, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 61, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 61, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 62, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 62, magicsOut);
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 63, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i + 63, magicsOut);
} }
#pragma GCC unroll 4 #pragma GCC unroll 4
for(; i < size; ++i) { for(; i < size; ++i) {
OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i, radicsOut); OccurenceMagic<DIGITS - 1, COUNTER_TYP>(arr, i, magicsOut);
} }
} }
/** Recursive Functor: no class should be generated I think (compiler should be smart) */ /** Recursive Functor: no class should be generated I think (compiler should be smart) */
template<int DIGIT, typename COUNTER_TYP> template<int DIGIT, typename COUNTER_TYP>
struct PrefixMagic : public PrefixMagic<DIGIT - 1, COUNTER_TYP> { struct PrefixMagic : public PrefixMagic<DIGIT - 1, COUNTER_TYP> {
inline __attribute__((always_inline)) PrefixMagic(COUNTER_TYP *radics, COUNTER_TYP *prev, int i) noexcept inline __attribute__((always_inline)) PrefixMagic(COUNTER_TYP *magics, COUNTER_TYP *prev, int i) noexcept
: PrefixMagic<DIGIT - 1, COUNTER_TYP>(radics, prev, i) { : PrefixMagic<DIGIT - 1, COUNTER_TYP>(magics, prev, i) {
static constexpr int DSTART = (DIGIT * DIGIT_RANGE); static constexpr int DSTART = (DIGIT * DIGIT_RANGE);
radics[DSTART + i] += prev[DIGIT]; magics[DSTART + i] += prev[DIGIT];
prev[DIGIT] = radics[DSTART + i]; prev[DIGIT] = magics[DSTART + i];
} }
}; };
/** Ends template recursion */ /** Ends template recursion */
template<typename COUNTER_TYP> template<typename COUNTER_TYP>
struct PrefixMagic<-1, COUNTER_TYP> { struct PrefixMagic<-1, COUNTER_TYP> {
inline PrefixMagic(COUNTER_TYP *radics, COUNTER_TYP *prev, int i) noexcept {} inline PrefixMagic(COUNTER_TYP *magics, COUNTER_TYP *prev, int i) noexcept {}
}; };
/** Gets REFERENCE to the given digit from the radix-array that has more than one digits */ /** Gets REFERENCE to the given digit from the radix-array that has more than one digits */
template<int DIGIT, typename COUNTER_TYP> template<int DIGIT, typename COUNTER_TYP>
static inline __attribute__((always_inline)) COUNTER_TYP &rGet(COUNTER_TYP *radics, int i) noexcept { static inline __attribute__((always_inline)) COUNTER_TYP &rGet(COUNTER_TYP *magics, int i) noexcept {
static constexpr int DSTART = (DIGIT * DIGIT_RANGE); static constexpr int DSTART = (DIGIT * DIGIT_RANGE);
return radics[DSTART + i]; return magics[DSTART + i];
} }
/** Helper for calcPrefixSums */ /** Helper for calcPrefixSums */
template<int DIGIT, typename COUNTER_TYP> template<int DIGIT, typename COUNTER_TYP>
struct PMagic2 : public PMagic2<DIGIT - 1, COUNTER_TYP> { struct PMagic2 : public PMagic2<DIGIT - 1, COUNTER_TYP> {
inline __attribute__((always_inline)) PMagic2(COUNTER_TYP *radics, COUNTER_TYP *prev) inline __attribute__((always_inline)) PMagic2(COUNTER_TYP *magics, COUNTER_TYP *prev)
: PMagic2<DIGIT - 1, COUNTER_TYP>(radics, prev) { : PMagic2<DIGIT - 1, COUNTER_TYP>(magics, prev) {
// Again first the 0th digit because of parent constructors! // Again first the 0th digit because of parent constructors!
// This is a template-unrolled loop too // This is a template-unrolled loop too
PrefixMagic<DIGITS - 1, COUNTER_TYP>(radics, prev, DIGIT); PrefixMagic<DIGITS - 1, COUNTER_TYP>(magics, prev, DIGIT);
} }
}; };
/** Template recursion endpoint */ /** Template recursion endpoint */
template<typename COUNTER_TYP> template<typename COUNTER_TYP>
struct PMagic2<-1, COUNTER_TYP> { struct PMagic2<-1, COUNTER_TYP> {
inline __attribute__((always_inline)) PMagic2(COUNTER_TYP *radics, COUNTER_TYP *prev) {} inline __attribute__((always_inline)) PMagic2(COUNTER_TYP *magics, COUNTER_TYP *prev) {}
}; };
template<typename COUNTER_TYP> template<typename COUNTER_TYP>
static inline void calcPrefixSums(COUNTER_TYP *radics) noexcept { static inline void calcPrefixSums(COUNTER_TYP *magics) noexcept {
static thread_local COUNTER_TYP prev[DIGITS]; static thread_local COUNTER_TYP prev[DIGITS];
memset(prev, 0, sizeof(prev)); memset(prev, 0, sizeof(prev));
// This is a template-unrolled loop too // This is a template-unrolled loop too
if constexpr (DIGIT_RANGE < 1024) { if constexpr (DIGIT_RANGE < 1024) {
// Extra optimization for bytes and nibbles - totally unrolled loop! // Extra optimization for bytes and nibbles - totally unrolled loop!
PMagic2<DIGIT_RANGE - 1, COUNTER_TYP>(radics, prev); PMagic2<DIGIT_RANGE - 1, COUNTER_TYP>(magics, prev);
} else { } else {
// The above would not work for words and higher up... // The above would not work for words and higher up...
#pragma GCC unroll 16 #pragma GCC unroll 16
@ -257,8 +257,8 @@ namespace MagyarSort {
#pragma GCC unroll 64 #pragma GCC unroll 64
for(int i = 0; i < DIGIT_RANGE; ++i) { for(int i = 0; i < DIGIT_RANGE; ++i) {
int DSTART = (j * DIGIT_RANGE); int DSTART = (j * DIGIT_RANGE);
radics[DSTART + i] += prev[j]; magics[DSTART + i] += prev[j];
prev[j] = radics[DSTART + i]; prev[j] = magics[DSTART + i];
} }
} }
} }
@ -267,8 +267,8 @@ namespace MagyarSort {
/** Recursive Functor: no class should be generated I think (compiler should be smart) */ /** Recursive Functor: no class should be generated I think (compiler should be smart) */
template<int DIGIT, typename COUNTER_TYP> template<int DIGIT, typename COUNTER_TYP>
struct RadixMagic : public RadixMagic<DIGIT - 1, COUNTER_TYP> { struct RadixMagic : public RadixMagic<DIGIT - 1, COUNTER_TYP> {
inline __attribute__((always_inline)) RadixMagic(bool &swapped, COUNTER_TYP *radics, uint32_t *from, uint32_t *to, COUNTER_TYP size) noexcept inline __attribute__((always_inline)) RadixMagic(bool &swapped, COUNTER_TYP *magics, uint32_t *from, uint32_t *to, COUNTER_TYP size) noexcept
: RadixMagic<DIGIT - 1, COUNTER_TYP>(swapped, radics, from, to, size) { : RadixMagic<DIGIT - 1, COUNTER_TYP>(swapped, magics, from, to, size) {
// Tricky: see (**) // Tricky: see (**)
if(swapped) { // never true for DIGIT 0, see (***) if(swapped) { // never true for DIGIT 0, see (***)
std::swap(from, to); std::swap(from, to);
@ -288,7 +288,7 @@ namespace MagyarSort {
// Get num and its new offset / location // Get num and its new offset / location
auto num = from[i - 1]; auto num = from[i - 1];
auto digVal = getDigit<DIGIT>(num); auto digVal = getDigit<DIGIT>(num);
auto offset = (--rGet<DIGIT>(radics, digVal)); auto offset = (--rGet<DIGIT>(magics, digVal));
// Add to the proper target location // Add to the proper target location
to[offset] = num; to[offset] = num;
@ -305,7 +305,7 @@ namespace MagyarSort {
/** Ends template recursion */ /** Ends template recursion */
template<typename COUNTER_TYP> template<typename COUNTER_TYP>
struct RadixMagic<-1, COUNTER_TYP> { struct RadixMagic<-1, COUNTER_TYP> {
inline RadixMagic(bool swapped, COUNTER_TYP *radics, uint32_t *&from, uint32_t *&to, COUNTER_TYP size) noexcept {} inline RadixMagic(bool swapped, COUNTER_TYP *magics, uint32_t *&from, uint32_t *&to, COUNTER_TYP size) noexcept {}
}; };
/* SORT */ /* SORT */
@ -349,26 +349,26 @@ namespace MagyarSort {
// Holds "digit" occurences, prefix sums, whatevers // Holds "digit" occurences, prefix sums, whatevers
// First "DIGIT_RANGE" elem is for MSB "DIGITS", last is for LSB // First "DIGIT_RANGE" elem is for MSB "DIGITS", last is for LSB
static thread_local COUNTER_TYP radics[DIGITS * DIGIT_RANGE]; static thread_local COUNTER_TYP magics[DIGITS * DIGIT_RANGE];
#ifndef NO_MLOCK #ifndef NO_MLOCK
mlock(radics, (DIGITS * DIGIT_RANGE) * sizeof(COUNTER_TYP)); mlock(magics, (DIGITS * DIGIT_RANGE) * sizeof(COUNTER_TYP));
#endif // !NO_MLOCK #endif // !NO_MLOCK
// Write prefetchin' // Write prefetchin'
//__builtin_prefetch(&radicsOut[..], 1); //__builtin_prefetch(&magicsOut[..], 1);
if constexpr (DIGIT_RANGE <= 1024) { if constexpr (DIGIT_RANGE <= 1024) {
PrefetchMagic<DIGITS * DIGIT_RANGE, (64/sizeof(COUNTER_TYP)), COUNTER_TYP, 1/*w*/> pm(radics); PrefetchMagic<DIGITS * DIGIT_RANGE, (64/sizeof(COUNTER_TYP)), COUNTER_TYP, 1/*w*/> pm(magics);
} }
memset(radics, 0, sizeof(radics)); memset(magics, 0, sizeof(magics));
// Calculate occurences of digits // Calculate occurences of digits
countOccurences(arr, size, radics); countOccurences(arr, size, magics);
//debugRadics<COUNTER_TYP>(radics); //debugRadics<COUNTER_TYP>(magics);
// Calculate prefix sums // Calculate prefix sums
calcPrefixSums(radics); calcPrefixSums(magics);
//debugRadics<COUNTER_TYP>(radics); //debugRadics<COUNTER_TYP>(magics);
/* Regular (old) radix sort with small twist */ /* Regular (old) radix sort with small twist */
@ -397,7 +397,7 @@ namespace MagyarSort {
static thread_local bool swapped; static thread_local bool swapped;
swapped = false; // must be separate line swapped = false; // must be separate line
RadixMagic<DIGITS - 1, COUNTER_TYP> r(swapped, radics, from, to, size); RadixMagic<DIGITS - 1, COUNTER_TYP> r(swapped, magics, from, to, size);
// With an other API we could spare this copy if we can delete original arr and return ptr or something... // With an other API we could spare this copy if we can delete original arr and return ptr or something...
// I am fine with this... this is not my main idea anyways, just little ILP tweak to regular radix sort // I am fine with this... this is not my main idea anyways, just little ILP tweak to regular radix sort
@ -406,7 +406,7 @@ namespace MagyarSort {
memcpy(arr, to, size); memcpy(arr, to, size);
} }
#ifndef NO_MLOCK #ifndef NO_MLOCK
munlock(radics, (DIGITS * DIGIT_RANGE) * sizeof(COUNTER_TYP)); munlock(magics, (DIGITS * DIGIT_RANGE) * sizeof(COUNTER_TYP));
munlock(&arc[0], size * sizeof(uint32_t)); munlock(&arc[0], size * sizeof(uint32_t));
munlock(arr, size * sizeof(uint32_t)); munlock(arr, size * sizeof(uint32_t));
#endif // !NO_MLOCK #endif // !NO_MLOCK

6
test.cpp
View File

@ -9,8 +9,8 @@
//#define INPUT_MOD (65536*128) //#define INPUT_MOD (65536*128)
// Number of input elements to generate - unused when CREEL is defined! // Number of input elements to generate - unused when CREEL is defined!
//#define SORT_WIDTH 200000000 #define SORT_WIDTH 100000000
#define SORT_WIDTH 40000000 //#define SORT_WIDTH 40000000
// Uncomment this to use nibbles as digits and not bytes - CREEL defines this anyways // Uncomment this to use nibbles as digits and not bytes - CREEL defines this anyways
//#define MAGYAR_SORT_NIBBLE //#define MAGYAR_SORT_NIBBLE
@ -18,7 +18,7 @@
//#define PRINT_OUTPUT //#define PRINT_OUTPUT
// Uncomment if you want to see how many elements are unique and duplicant in the input (debugging info) // Uncomment if you want to see how many elements are unique and duplicant in the input (debugging info)
#define COUNT_DUPLICANTS // #define COUNT_DUPLICANTS
//#define SKA_SORT //#define SKA_SORT

105
ypsu.cpp
View File

@ -33,9 +33,17 @@ void measure(const std::string &inputtype, const std::string &name,
worst[name] = std::max(worst[name], seconds); worst[name] = std::max(worst[name], seconds);
} }
std::vector<std::string> inputtypes = { std::vector<std::string> inputtypes = {
/*"constant", "asc", "desc", "ascasc", "ascdesc", /*
"descasc", "descdesc", "smallrange",*/ "constant"
"asc"
"desc"
"ascasc"
"ascdesc",
"descasc"
"descdesc"
"rand", "rand",
*/
"smallrange",
}; };
std::vector<uint32_t> geninput(const std::string &type, int n) { std::vector<uint32_t> geninput(const std::string &type, int n) {
std::vector<uint32_t> v(n); std::vector<uint32_t> v(n);
@ -113,6 +121,84 @@ void twopass(uint32_t *a, int n) {
for (int i = 0; i < n; i++) a[bucketdata[buf[i] >> 16]++] = buf[i]; for (int i = 0; i < n; i++) a[bucketdata[buf[i] >> 16]++] = buf[i];
free(buf); free(buf);
} }
// TODO: zssort (quicksort jobbítás)
// mormord — Today at 2:27 AM
// 1 2 2 2 3
//
// 0 1 2 3 4
// |1|2 2 3 2
// 1|2|2 3 2
// 1|3|2 2 2
// 1|2|2 2 3
// 1|2|2 2 3
// 1 2|2|2 3
// ^
// Pivot
//
// állítás: pivottól balra helyükön vannak az elemek rendezettségük szerint
//
// Kezdés Indexek = Prefix összeg - 1 (utolsó helyek az elemeknek)
//
// Ha pivot új helyének meghatározot index > pivot_index (|.| helye)
// swap
// --index
// különben
// ++pivot_index
static inline uint32_t morgrab(uint32_t elem, uint32_t j) noexcept {
return (elem >> (8 * j)) & 0xff;
}
static inline void mormord_sort_impl(uint32_t *a, int n, int j) noexcept {
// Occurence count
uint32_t prefix[256] = { 0 };
uint32_t index[256] = { 0 };
for(uint32_t i = 0; i < n; ++i) {
// ++prefix[(a[i] >> (8 * j)) && 0xff];
++prefix[morgrab(a[i], j)];
}
// Prefix sum
index[0] = prefix[0];
for(uint32_t i = 1; i < 256; ++i) {
prefix[i] += prefix[i - 1];
index[i] = prefix[i];
}
// Inplace swap
uint32_t pivoti = 0;
while(pivoti < n) {
uint32_t radixval = morgrab(a[pivoti], j);
uint32_t targeti = index[radixval] - 1;
if(targeti > pivoti) {
// swap
uint32_t tmp = a[pivoti];
a[pivoti] = a[targeti];
a[targeti] = tmp;
// dec index
--index[radixval];
} else {
++pivoti;
}
}
// Ends recursion
if(j == 0) return;
// Recursion
for(uint32_t i = 0; i < 256; ++i) {
uint32_t from = index[i];
uint32_t to = prefix[i];
if(from != to) {
mormord_sort_impl(&a[from - 1], (to - (from - 1)), j - 1);
}
}
}
static inline void mormord_sort(uint32_t *a, int n) noexcept {
assert(n * uint32_t(sizeof(a[0])) <= INT_MAX);
mormord_sort_impl(a, n, 3);
}
void fourpass(uint32_t *a, int n) { void fourpass(uint32_t *a, int n) {
assert(n * int64_t(sizeof(a[0])) <= INT_MAX); assert(n * int64_t(sizeof(a[0])) <= INT_MAX);
// alloc helper buffers. // alloc helper buffers.
@ -510,11 +596,11 @@ void measure_single(int n) {
int main(void) { int main(void) {
//int n = 100000000; //int n = 100000000;
//int n = 10000000; //int n = 10000000;
int n = 1000000; //int n = 1000000;
//int n = 100000; //int n = 100000;
//int n = 10000; //int n = 10000;
//int n = 100; //int n = 100;
//int n = 10; int n = 10;
printf("Sorting %d elements:\n\n", n); printf("Sorting %d elements:\n\n", n);
@ -532,7 +618,6 @@ int main(void) {
measure(inputtype, "std", [&] { std::sort(std::begin(w), std::end(w)); }); measure(inputtype, "std", [&] { std::sort(std::begin(w), std::end(w)); });
expected = w; expected = w;
w = v; w = v;
/*
measure(inputtype, "ska", [&] { ska_sort(std::begin(w), std::end(w)); }); measure(inputtype, "ska", [&] { ska_sort(std::begin(w), std::end(w)); });
w = v; w = v;
measure(inputtype, "ska_copy", [&] { measure(inputtype, "ska_copy", [&] {
@ -541,9 +626,15 @@ int main(void) {
w.swap(buf); w.swap(buf);
} }
}); });
/*
w = v; w = v;
measure(inputtype, "magyar", [&] { MagyarSort::sort<uint32_t>(&w[0], w.size()); }); measure(inputtype, "magyar", [&] { MagyarSort::sort<uint32_t>(&w[0], w.size()); });
assert(w == expected); assert(w == expected);
*/
w = v;
measure(inputtype, "mormord", [&] { mormord_sort(&w[0], w.size()); });
assert(w == expected);
/*
w = v; w = v;
measure(inputtype, "2pass", [&] { twopass(&w[0], w.size()); }); measure(inputtype, "2pass", [&] { twopass(&w[0], w.size()); });
@ -563,17 +654,16 @@ int main(void) {
w = v; w = v;
measure(inputtype, "sp", [&] { spsort(&w[0], w.size()); }); measure(inputtype, "sp", [&] { spsort(&w[0], w.size()); });
assert(w == expected);*/ assert(w == expected);*/
/*
w = v; w = v;
measure(inputtype, "gptbuck", [&] { gpt_bucket_sort(&w[0], w.size()); }); measure(inputtype, "gptbuck", [&] { gpt_bucket_sort(&w[0], w.size()); });
assert(w == expected); assert(w == expected);
/*
w = v; w = v;
measure(inputtype, "magbuck", [&] { magyar_bucket_sort(&w[0], w.size()); }); measure(inputtype, "magbuck", [&] { magyar_bucket_sort(&w[0], w.size()); });
assert(w == expected); assert(w == expected);
w = v; w = v;
measure(inputtype, "magbuck2", [&] { magyar_bucket_sort2(&w[0], w.size()); }); measure(inputtype, "magbuck2", [&] { magyar_bucket_sort2(&w[0], w.size()); });
assert(w == expected); assert(w == expected);
*/
w = v; w = v;
w = {10, 20, 20}; w = {10, 20, 20};
measure(inputtype, "qsmine", [&] { thier_quicksort(&w[0], w.size()); }); measure(inputtype, "qsmine", [&] { thier_quicksort(&w[0], w.size()); });
@ -597,6 +687,7 @@ int main(void) {
} }
} }
assert(w == expected); assert(w == expected);
*/
/* /*
w = v; w = v;
measure(inputtype, "frewr", [&] { frewr(&w[0], w.size()); }); measure(inputtype, "frewr", [&] { frewr(&w[0], w.size()); });