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

Revert "thier3 / tpxb: int->uint32, but this loses a little perf because likely compiler uses the UB of signed overflow to optimize out stuff so will be reverted as it is not a practical thing anyways"

Browse Source 
This reverts commit 808b87f266b2ce8a058b94d9183d100362abe1b4.
This commit is contained in:
Richard Thier 2025-10-01 02:06:23 +02:00
parent 808b87f266
commit 31dd239ad3
2 changed files with 36 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
thiersort3.h
View File

@ -52,13 +52,13 @@ static inline uint32_t witch_bucket3(uint32_t key) {
* @param n Number of elements in arr and temparr
* @param rstate Create with sch_rand_state rstate = schwab_rand_state(junk_uint32_t);
*/
static inline void thiersort3(uint32_t *arr, uint32_t *temparr, uint32_t n) {
uint32_t bucket[256]; /* Inclusive */
uint32_t bucket_end[256]; /* Not inclusive */
static inline void thiersort3(uint32_t *arr, uint32_t *temparr, int n) {
int bucket[256]; /* Inclusive */
int bucket_end[256]; /* Not inclusive */
#ifndef NO_EXTRA_BIT
uint32_t bucket_leftend[256]; /* for extra 1bit split processing */
uint32_t bucket_left[256]; /* for extra 1bit split processing */
int bucket_leftend[256]; /* for extra 1bit split processing */
int bucket_left[256]; /* for extra 1bit split processing */
#endif /* NO_EXTRA_BIT */
/* Check if need to sort at all - needed for invariants later */
@ -68,25 +68,25 @@ static inline void thiersort3(uint32_t *arr, uint32_t *temparr, uint32_t n) {
/* Count */
#pragma GCC unroll 64
for(uint32_t i = 0; i < 256; ++i) {
for(int i = 0; i < 256; ++i) {
bucket[i] = 0;
}
#pragma GCC unroll 128
for(uint32_t i = 0; i < n; ++i) {
for(int i = 0; i < n; ++i) {
++bucket[witch_bucket3(arr[i])];
}
/* Prefix sum (like in Magyarsort) */
uint32_t prev = 0;
#pragma GCC unroll 4
for (uint32_t i = 0; i < 256; i++) {
for (int i = 0; i < 256; i++) {
bucket[i] += prev;
prev = bucket[i];
}
/* Save end-offsets */
#pragma GCC unroll 64
for(uint32_t i = 0; i < 256; ++i) {
for(int i = 0; i < 256; ++i) {
bucket_end[i] = bucket[i];
}
@ -95,7 +95,7 @@ static inline void thiersort3(uint32_t *arr, uint32_t *temparr, uint32_t n) {
bucket_left[0] = 0;
bucket_leftend[0] = 0;
#pragma GCC unroll 64
for(uint32_t i = 0; i < 255; ++i) {
for(int i = 0; i < 4095; ++i) {
bucket_left[1 + i] = bucket[i];
bucket_leftend[1 + i] = bucket[i];
}
@ -106,18 +106,18 @@ static inline void thiersort3(uint32_t *arr, uint32_t *temparr, uint32_t n) {
/* Move to the buckets */
/* Rem.: This also changes bucket[i] so they will point to bucket beginnings */
#pragma GCC unroll 128
for(uint32_t i = 0; i < n; ++i) {
for(int i = 0; i < n; ++i) {
uint32_t num = arr[i];
uint32_t witch = witch_bucket3(num);
uint32_t offset = (--bucket[witch]);
int offset = (--bucket[witch]);
temparr[offset] = num;
}
/* temparr -> arr each bucket and sort them in-place */
#pragma GCC unroll 2
for(uint32_t b = 0; b < 256; ++b) {
uint32_t begin = bucket[b];
uint32_t end = bucket_end[b];
for(int b = 0; b < 256; ++b) {
int begin = bucket[b];
int end = bucket_end[b];
/* Ensure exists */
if(begin >= end) {
@ -137,10 +137,10 @@ static inline void thiersort3(uint32_t *arr, uint32_t *temparr, uint32_t n) {
/* Rem.: This also changes bucket[i] so they will point to bucket.right beginnings */
/* Rem.: This also changes bucket_leftend[i] so they will point to bucket.left endings (needed in-process only) */
#pragma GCC unroll 64
for(uint32_t i = 0; i < n; ++i) {
for(int i = 0; i < n; ++i) {
uint32_t num = arr[i];
uint32_t witch = witch_bucket3(num);
uint32_t offset = (num & (1 << 27)) ?
int offset = (num & (1 << 27)) ?
(--bucket[witch]) :
(bucket_leftend[witch]++);
@ -149,12 +149,12 @@ static inline void thiersort3(uint32_t *arr, uint32_t *temparr, uint32_t n) {
/* temparr -> arr each bucket and sort them in-place */
#pragma GCC unroll 2
for(uint32_t b = 0; b < 256; ++b) {
for(int b = 0; b < 256; ++b) {
assert(bucket_leftend[b] == bucket[b]);
uint32_t lbegin = bucket_left[b];
uint32_t lend = bucket[b]; /* non-inclusive */
uint32_t rbegin = bucket[b];
uint32_t rend = bucket_end[b]; /* non-inclusive */
int lbegin = bucket_left[b];
int lend = bucket[b]; /* non-inclusive */
int rbegin = bucket[b];
int rend = bucket_end[b]; /* non-inclusive */
/* Ensure exists and process left part */
if(lbegin < lend) {

25
threepass_xbit.h
View File

@ -31,14 +31,17 @@ static inline constexpr uint32_t min3u32_xb(uint32_t a, uint32_t b, uint32_t c)
* @param buf Result array with the same size - result will be here
* @param n The number of elements
*/
static inline void threepass_xb(uint32_t *a, uint32_t *buf, uint32_t n) noexcept {
static inline void threepass_xb(uint32_t *a, uint32_t *buf, int n) noexcept {
assert(buf != NULL);
constexpr uint32_t shr1 = TPBX3 + TPBX2;
constexpr uint32_t shr2 = TPBX3;
constexpr uint32_t shr3 = 0;
constexpr uint32_t mask1 = (1 << TPBX1) - 1;
constexpr uint32_t mask2 = (1 << TPBX2) - 1;
constexpr uint32_t mask3 = (1 << TPBX3) - 1;
constexpr int shr1 = TPBX3 + TPBX2;
constexpr int shr2 = TPBX3;
constexpr int shr3 = 0;
constexpr int mask1 = (1 << TPBX1) - 1;
constexpr int mask2 = (1 << TPBX2) - 1;
constexpr int mask3 = (1 << TPBX3) - 1;
/* helper buffers. */
int sz = n * sizeof(a[0]);
static thread_local uint32_t bucket1[1 << TPBX1];
memset(bucket1, 0, (1 << TPBX1) * sizeof(uint32_t));
@ -64,7 +67,7 @@ static inline void threepass_xb(uint32_t *a, uint32_t *buf, uint32_t n) noexcept
(1 << TPBX2),
(1 << TPBX3)
);
uint32_t i = 0;
int i = 0;
#pragma GCC unroll 8
for (; i < common; ++i) {
bucket1[i] += prev1;
@ -75,17 +78,17 @@ static inline void threepass_xb(uint32_t *a, uint32_t *buf, uint32_t n) noexcept
prev3 = bucket3[i];
}
/* Do remaining 1 */
for (uint32_t j = i; j < (1 << TPBX1); ++j) {
for (int j = i; j < (1 << TPBX1); ++j) {
bucket1[j] += prev1;
prev1 = bucket1[j];
}
/* Do remaining 2 */
for (uint32_t j = i; j< (1 << TPBX2); ++j) {
for (int j = i; j< (1 << TPBX2); ++j) {
bucket2[j] += prev2;
prev2 = bucket2[j];
}
/* Do remaining 3 */
for (uint32_t j = i; j < (1 << TPBX3); ++j) {
for (int j = i; j < (1 << TPBX3); ++j) {
bucket3[j] += prev3;
prev3 = bucket3[j];
}