kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-05-01 17:19:36 +00:00
Code Issues Releases Wiki Activity

Get rid of PairsData allocation kludge

Browse source 
Currently we malloc a single memory
chunk in which we shuffle all kind of
different stuff in a very tricky way,
for instance see PairsData::base[1]
that is a hack used as a pointer to
data instead of an actual array (no
wonder C++ compiler complains!).

This patch rewrites all this in a way
to avoid hacky allocations and instead
to rely on the standard containers to
do their job.

This is the base for future work.
This commit is contained in:
Marco Costalba 2016-04-28 11:38:14 +02:00
parent efc8557b2d
commit 9cf110a2ae
1 changed files with 45 additions and 48 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

93
src/syzygy/tbprobe.cpp
View file

@ -53,16 +53,19 @@ inline Square operator^=(Square& s, int i) { return s = Square(int(s) ^ i); }
inline Square operator^(Square s, int i) { return Square(int(s) ^ i); } inline Square operator^(Square s, int i) { return Square(int(s) ^ i); }
struct PairsData { struct PairsData {
char *indextable; char* indextable;
uint16_t *sizetable; uint16_t* sizetable;
uint8_t *data; uint8_t* data;
uint16_t *offset; uint16_t* offset;
uint8_t *symlen; uint8_t* sympat;
uint8_t *sympat;
int blocksize; int blocksize;
int idxbits; int idxbits;
int real_num_blocks;
int num_blocks;
int max_len;
int min_len; int min_len;
base_t base[1]; // C++ complains about base[]... std::vector<base_t> base;
std::vector<uint8_t> symlen;
}; };
class WDLEntry { class WDLEntry {
@ -522,12 +525,12 @@ WDLEntry::~WDLEntry()
if (has_pawns) if (has_pawns)
for (File f = FILE_A; f <= FILE_D; ++f) { for (File f = FILE_A; f <= FILE_D; ++f) {
free(pawn.file[0][f].precomp); delete pawn.file[0][f].precomp;
free(pawn.file[1][f].precomp); delete pawn.file[1][f].precomp;
} }
else { else {
free(piece[0].precomp); delete piece[0].precomp;
free(piece[1].precomp); delete piece[1].precomp;
} }
} }
@ -556,9 +559,9 @@ DTZEntry::~DTZEntry()
if (has_pawns) if (has_pawns)
for (File f = FILE_A; f <= FILE_D; ++f) for (File f = FILE_A; f <= FILE_D; ++f)
free(pawn.file[f].precomp); delete pawn.file[f].precomp;
else else
free(piece.precomp); delete piece.precomp;
} }
// Given a position with 6 or fewer pieces, produce a text string // Given a position with 6 or fewer pieces, produce a text string
@ -830,7 +833,7 @@ void set_norms(T& p, int num, uint8_t pawns[])
++p.norm[i]; ++p.norm[i];
} }
void calc_symlen(PairsData *d, int s, char *tmp) void calc_symlen(PairsData* d, int s, std::vector<char>& tmp)
{ {
int s1, s2; int s1, s2;
@ -864,15 +867,14 @@ uint32_t ReadUint32(uint8_t* d)
return d[0] | (d[1] << 8) | (d[2] << 16) | (d[3] << 24); return d[0] | (d[1] << 8) | (d[2] << 16) | (d[3] << 24);
} }
PairsData *setup_pairs(uint8_t *data, uint64_t tb_size, uint64_t *size, unsigned char **next, uint8_t *flags, int wdl) PairsData* setup_pairs(uint8_t *data, uint64_t tb_size, uint64_t *size, unsigned char **next, uint8_t *flags, int wdl)
{ {
PairsData *d;
int i; int i;
*flags = data[0]; *flags = data[0];
if (data[0] & 0x80) { if (data[0] & 0x80) {
d = (PairsData *)malloc(sizeof(PairsData)); PairsData* d = new PairsData();
d->idxbits = 0; d->idxbits = 0;
if (wdl) if (wdl)
@ -885,33 +887,30 @@ PairsData *setup_pairs(uint8_t *data, uint64_t tb_size, uint64_t *size, unsigned
return d; return d;
} }
int blocksize = data[1]; PairsData* d = new PairsData();
int idxbits = data[2]; d->blocksize = data[1];
int real_num_blocks = ReadUint32(&data[4]); d->idxbits = data[2];
int num_blocks = real_num_blocks + *(uint8_t *)(&data[3]); d->real_num_blocks = ReadUint32(&data[4]);
int max_len = data[8]; d->num_blocks = d->real_num_blocks + *(uint8_t *)(&data[3]);
int min_len = data[9]; d->max_len = data[8];
int h = max_len - min_len + 1; d->min_len = data[9];
int num_syms = ReadUshort(&data[10 + 2 * h]);
d = (PairsData *)malloc(sizeof(PairsData) + (h - 1) * sizeof(base_t) + num_syms);
d->blocksize = blocksize;
d->idxbits = idxbits;
d->offset = (uint16_t*)(&data[10]); d->offset = (uint16_t*)(&data[10]);
d->symlen = ((uint8_t *)d) + sizeof(PairsData) + (h - 1) * sizeof(base_t);
int h = d->max_len - d->min_len + 1;
int num_syms = ReadUshort(&data[10 + 2 * h]);
d->sympat = &data[12 + 2 * h]; d->sympat = &data[12 + 2 * h];
d->min_len = min_len; d->base.resize(h);
d->symlen.resize(num_syms);
*next = &data[12 + 2 * h + 3 * num_syms + (num_syms & 1)]; *next = &data[12 + 2 * h + 3 * num_syms + (num_syms & 1)];
uint64_t num_indices = (tb_size + (1ULL << idxbits) - 1) >> idxbits; uint64_t num_indices = (tb_size + (1ULL << d->idxbits) - 1) >> d->idxbits;
size[0] = 6ULL * num_indices; size[0] = 6ULL * num_indices;
size[1] = 2ULL * num_blocks; size[1] = 2ULL * d->num_blocks;
size[2] = (1ULL << blocksize) * real_num_blocks; size[2] = (1ULL << d->blocksize) * d->real_num_blocks;
// char tmp[num_syms]; std::vector<char> tmp(num_syms);
char tmp[4096];
for (i = 0; i < num_syms; ++i)
tmp[i] = 0;
for (i = 0; i < num_syms; ++i) for (i = 0; i < num_syms; ++i)
if (!tmp[i]) if (!tmp[i])
@ -923,7 +922,7 @@ PairsData *setup_pairs(uint8_t *data, uint64_t tb_size, uint64_t *size, unsigned
d->base[i] = (d->base[i + 1] + ReadUshort((uint8_t*)(d->offset + i)) - ReadUshort((uint8_t*)(d->offset + i + 1))) / 2; d->base[i] = (d->base[i + 1] + ReadUshort((uint8_t*)(d->offset + i)) - ReadUshort((uint8_t*)(d->offset + i + 1))) / 2;
for (i = 0; i < h; ++i) for (i = 0; i < h; ++i)
d->base[i] <<= 64 - (min_len + i); d->base[i] <<= 64 - (d->min_len + i);
d->offset -= d->min_len; d->offset -= d->min_len;
@ -1228,8 +1227,6 @@ int decompress_pairs(PairsData* d, uint64_t idx)
int m = d->min_len; int m = d->min_len;
uint16_t *offset = d->offset; uint16_t *offset = d->offset;
base_t* base = d->base - m;
uint8_t* symlen = d->symlen;
int sym, bitcnt; int sym, bitcnt;
ptr += 2; ptr += 2;
@ -1238,7 +1235,7 @@ int decompress_pairs(PairsData* d, uint64_t idx)
for (;;) { for (;;) {
int l = m; int l = m;
while (code < base[l]) while (code < d->base[l - d->min_len])
++l; ++l;
sym = offset[l]; sym = offset[l];
@ -1246,12 +1243,12 @@ int decompress_pairs(PairsData* d, uint64_t idx)
if (!LittleEndian) if (!LittleEndian)
sym = ((sym & 0xff) << 8) | (sym >> 8); sym = ((sym & 0xff) << 8) | (sym >> 8);
sym += (int)((code - base[l]) >> (64 - l)); sym += (int)((code - d->base[l - d->min_len]) >> (64 - l));
if (litidx < (int)symlen[sym] + 1) if (litidx < (int)d->symlen[sym] + 1)
break; break;
litidx -= (int)symlen[sym] + 1; litidx -= (int)d->symlen[sym] + 1;
code <<= l; code <<= l;
bitcnt += l; bitcnt += l;
@ -1268,14 +1265,14 @@ int decompress_pairs(PairsData* d, uint64_t idx)
uint8_t *sympat = d->sympat; uint8_t *sympat = d->sympat;
while (symlen[sym] != 0) { while (d->symlen[sym] != 0) {
uint8_t* w = sympat + (3 * sym); uint8_t* w = sympat + (3 * sym);
int s1 = ((w[1] & 0xf) << 8) | w[0]; int s1 = ((w[1] & 0xf) << 8) | w[0];
if (litidx < (int)symlen[s1] + 1) if (litidx < (int)d->symlen[s1] + 1)
sym = s1; sym = s1;
else { else {
litidx -= (int)symlen[s1] + 1; litidx -= (int)d->symlen[s1] + 1;
sym = (w[2] << 4) | (w[1] >> 4); sym = (w[2] << 4) | (w[1] >> 4);
} }
} }