120 lines
3.1 KiB
C
120 lines
3.1 KiB
C
#ifndef _rank_h_INCLUDED
|
|
#define _rank_h_INCLUDED
|
|
|
|
#include "allocate.h"
|
|
|
|
#include <string.h>
|
|
|
|
#ifdef NDEBUG
|
|
#define CHECK_RANKED(...) do { } while (0)
|
|
#else
|
|
#define CHECK_RANKED(N,A,RANK) \
|
|
do { \
|
|
for (size_t I_CHECK_RANKED = 0; I_CHECK_RANKED < N-1; I_CHECK_RANKED++) \
|
|
assert (RANK (A[I_CHECK_RANKED]) <= RANK (A[I_CHECK_RANKED + 1])); \
|
|
} while (0)
|
|
#endif
|
|
|
|
#define RADIX(LENGTH,VTYPE,RTYPE,N,V,RANK) \
|
|
do { \
|
|
const size_t N_RADIX = (N); \
|
|
if (N_RADIX <= 1) \
|
|
break; \
|
|
\
|
|
START (radix); \
|
|
\
|
|
VTYPE * V_RADIX = (V); \
|
|
\
|
|
const size_t LENGTH_RADIX = (LENGTH); \
|
|
const size_t WIDTH_RADIX = (1 << LENGTH_RADIX); \
|
|
const RTYPE MASK_RADIX = WIDTH_RADIX - 1; \
|
|
\
|
|
size_t COUNT_RADIX[WIDTH_RADIX]; \
|
|
\
|
|
VTYPE * TMP_RADIX = 0; \
|
|
const size_t BYTES_TMP_RADIX = N_RADIX * sizeof (VTYPE); \
|
|
\
|
|
VTYPE * A_RADIX = V_RADIX; \
|
|
VTYPE * B_RADIX = 0; \
|
|
VTYPE * C_RADIX = A_RADIX; \
|
|
\
|
|
RTYPE MLOWER_RADIX = 0; \
|
|
RTYPE MUPPER_RADIX = MASK_RADIX; \
|
|
\
|
|
for (size_t I_RADIX = 0; \
|
|
I_RADIX < 8 * sizeof (RTYPE); \
|
|
I_RADIX += LENGTH_RADIX) \
|
|
{ \
|
|
memset (COUNT_RADIX + MLOWER_RADIX, 0, \
|
|
(MUPPER_RADIX - MLOWER_RADIX + 1) * sizeof *COUNT_RADIX); \
|
|
\
|
|
VTYPE * END_RADIX = C_RADIX + N_RADIX; \
|
|
RTYPE UPPER_RADIX = 0; \
|
|
RTYPE LOWER_RADIX = ~UPPER_RADIX; \
|
|
\
|
|
for (VTYPE * P_RADIX = C_RADIX; P_RADIX != END_RADIX; P_RADIX++) \
|
|
{ \
|
|
RTYPE R_RADIX = RANK (*P_RADIX); \
|
|
RTYPE S_RADIX = R_RADIX >> I_RADIX; \
|
|
RTYPE M_RADIX = S_RADIX & MASK_RADIX; \
|
|
LOWER_RADIX &= S_RADIX; \
|
|
UPPER_RADIX |= S_RADIX; \
|
|
COUNT_RADIX[M_RADIX]++; \
|
|
} \
|
|
\
|
|
if (LOWER_RADIX == UPPER_RADIX) \
|
|
break; \
|
|
\
|
|
MLOWER_RADIX = LOWER_RADIX & MASK_RADIX; \
|
|
MUPPER_RADIX = UPPER_RADIX & MASK_RADIX; \
|
|
\
|
|
size_t POS_RADIX = 0; \
|
|
for (size_t J_RADIX = MLOWER_RADIX; J_RADIX <= MUPPER_RADIX; J_RADIX++) \
|
|
{ \
|
|
const size_t DELTA_RADIX = COUNT_RADIX[J_RADIX]; \
|
|
COUNT_RADIX[J_RADIX] = POS_RADIX; \
|
|
POS_RADIX += DELTA_RADIX; \
|
|
} \
|
|
\
|
|
if (!TMP_RADIX) \
|
|
{ \
|
|
assert (C_RADIX == A_RADIX); \
|
|
TMP_RADIX = kissat_malloc (solver, BYTES_TMP_RADIX); \
|
|
B_RADIX = TMP_RADIX; \
|
|
} \
|
|
\
|
|
assert (B_RADIX == TMP_RADIX); \
|
|
\
|
|
VTYPE * D_RADIX = (C_RADIX == A_RADIX) ? B_RADIX : A_RADIX; \
|
|
\
|
|
for (VTYPE * P_RADIX = C_RADIX; P_RADIX != END_RADIX; P_RADIX++) \
|
|
{ \
|
|
RTYPE R_RADIX = RANK (*P_RADIX); \
|
|
RTYPE S_RADIX = R_RADIX >> I_RADIX; \
|
|
RTYPE M_RADIX = S_RADIX & MASK_RADIX; \
|
|
const size_t POS_RADIX = COUNT_RADIX[M_RADIX]++; \
|
|
D_RADIX[POS_RADIX] = *P_RADIX; \
|
|
} \
|
|
\
|
|
C_RADIX = D_RADIX; \
|
|
} \
|
|
\
|
|
if (C_RADIX == B_RADIX) \
|
|
memcpy (A_RADIX, B_RADIX, N_RADIX * sizeof *A_RADIX); \
|
|
\
|
|
if (TMP_RADIX) \
|
|
kissat_free (solver, TMP_RADIX, BYTES_TMP_RADIX); \
|
|
\
|
|
CHECK_RANKED (N_RADIX, V_RADIX, RANK); \
|
|
STOP (radix); \
|
|
} while (0)
|
|
|
|
#define RADIX_STACK(LENGTH,VTYPE,RTYPE,S,RANK) \
|
|
do { \
|
|
const size_t N_RADIX_STACK = SIZE_STACK (S); \
|
|
VTYPE * A_RADIX_STACK = BEGIN_STACK (S); \
|
|
RADIX(LENGTH,VTYPE,RTYPE,N_RADIX_STACK,A_RADIX_STACK,RANK); \
|
|
} while (0)
|
|
|
|
#endif
|