{

if (! _constantsSet)

{

_constantsSet = true;

TransTableL::SetConstants();

}

poolp = nullptr;

pagesDefault = NUM_PAGES_DEFAULT;

pagesMaximum = NUM_PAGES_MAXIMUM;

pagesCurrent = 0;

memState = FROM_POOL;

harvestTrick = FIRST_HARVEST_TRICK;

harvestHand = 0;

harvested.nextBlockNo = 0;

timestamp = 0;

pageStats.numResets = 0;

pageStats.numCallocs = 0;

pageStats.numFrees = 0;

pageStats.numHarvests = 0;

pageStats.lastCurrent = 0;

TTInUse = 0;

{

unsigned int topBitRank = 1;

TTlowestRank[0] = 15; // Void

unsigned winMask[8192];

winMask[0] = 0;

for (unsigned ind = 1; ind < 8192; ind++)

{

if (ind >= (topBitRank + topBitRank)) /* Next top bit */

topBitRank <<= 1;

// winMask is a growing list of 11's. In the end it will

// have 26 bits, so 13 groups of two bits. It always

// consists of all 11's, then all 00's.

winMask[ind] = (winMask[ind ^ topBitRank] >> 2) | (3 << 24);

maskBytes[ind][0][0] = (winMask[ind] << 6) & 0xff000000;

maskBytes[ind][0][1] = (winMask[ind] << 14) & 0xff000000;

maskBytes[ind][0][2] = (winMask[ind] << 22) & 0xff000000;

maskBytes[ind][0][3] = (winMask[ind] << 30) & 0xff000000;

maskBytes[ind][1][0] = (winMask[ind] >> 2) & 0x00ff0000;

maskBytes[ind][1][1] = (winMask[ind] << 6) & 0x00ff0000;

maskBytes[ind][1][2] = (winMask[ind] << 14) & 0x00ff0000;

maskBytes[ind][1][3] = (winMask[ind] << 22) & 0x00ff0000;

maskBytes[ind][2][0] = (winMask[ind] >> 10) & 0x0000ff00;

maskBytes[ind][2][1] = (winMask[ind] >> 2) & 0x0000ff00;

maskBytes[ind][2][2] = (winMask[ind] << 6) & 0x0000ff00;

maskBytes[ind][2][3] = (winMask[ind] << 14) & 0x0000ff00;

maskBytes[ind][3][0] = (winMask[ind] >> 18) & 0x000000ff;

maskBytes[ind][3][1] = (winMask[ind] >> 10) & 0x000000ff;

maskBytes[ind][3][2] = (winMask[ind] >> 2) & 0x000000ff;

maskBytes[ind][3][3] = (winMask[ind] << 6) & 0x000000ff;

TTlowestRank[ind] = TTlowestRank[ind ^ topBitRank] - 1;

}

{

// This is very similar to SetConstants, except that it

// happens with actual cards. It also makes sense to

// keep a record of aggrRanks for each suit. These are

// only used later for xorSet.

unsigned int topBitRank = 1;

unsigned int topBitNo = 2;

aggrType * ap;

for (int s = 0; s < DDS_SUITS; s++)

{

aggr[0].aggrRanks[s] = 0;

aggr[0].aggrBytes[s][0] = 0;

aggr[0].aggrBytes[s][1] = 0;

aggr[0].aggrBytes[s][2] = 0;

aggr[0].aggrBytes[s][3] = 0;

}

for (unsigned ind = 1; ind < 8192; ind++)

{

if (ind >= (topBitRank << 1))

{

/* Next top bit */

topBitRank <<= 1;

topBitNo++;

}

aggr[ind] = aggr[ind ^ topBitRank];

ap = &aggr[ind];

for (int s = 0; s < DDS_SUITS; s++)

{

ap->aggrRanks[s] = ap->aggrRanks[s] >> 2 |

static_cast<unsigned>(handLookup[s][topBitNo] << 24);

}

ap->aggrBytes[0][0] = (ap->aggrRanks[0] << 6) & 0xff000000;

ap->aggrBytes[0][1] = (ap->aggrRanks[0] << 14) & 0xff000000;

ap->aggrBytes[0][2] = (ap->aggrRanks[0] << 22) & 0xff000000;

ap->aggrBytes[0][3] = (ap->aggrRanks[0] << 30) & 0xff000000;

ap->aggrBytes[1][0] = (ap->aggrRanks[1] >> 2) & 0x00ff0000;

ap->aggrBytes[1][1] = (ap->aggrRanks[1] << 6) & 0x00ff0000;

ap->aggrBytes[1][2] = (ap->aggrRanks[1] << 14) & 0x00ff0000;

ap->aggrBytes[1][3] = (ap->aggrRanks[1] << 22) & 0x00ff0000;

ap->aggrBytes[2][0] = (ap->aggrRanks[2] >> 10) & 0x0000ff00;

ap->aggrBytes[2][1] = (ap->aggrRanks[2] >> 2) & 0x0000ff00;

ap->aggrBytes[2][2] = (ap->aggrRanks[2] << 6) & 0x0000ff00;

ap->aggrBytes[2][3] = (ap->aggrRanks[2] << 14) & 0x0000ff00;

ap->aggrBytes[3][0] = (ap->aggrRanks[3] >> 18) & 0x000000ff;

ap->aggrBytes[3][1] = (ap->aggrRanks[3] >> 10) & 0x000000ff;

ap->aggrBytes[3][2] = (ap->aggrRanks[3] >> 2) & 0x000000ff;

ap->aggrBytes[3][3] = (ap->aggrRanks[3] << 6) & 0x000000ff;

}

{

double blockMem = BLOCKS_PER_PAGE * sizeof(winBlockType) /

static_cast<double>(1024.);

pagesDefault = static_cast<int>((1024 * megabytes) / blockMem);

{

double blockMem = BLOCKS_PER_PAGE * sizeof(winBlockType) /

static_cast<double>(1024.);

pagesMaximum = static_cast<int>((1024 * megabytes) / blockMem);

{

if (! TTInUse)

{

TTInUse = 1;

for (int t = 0; t < TT_TRICKS; t++)

{

for (int h = 0; h < DDS_HANDS; h++)

{

TTroot[t][h] = static_cast<distHashType *>

(malloc(256 * sizeof(distHashType)));

if (TTroot[t][h] == nullptr)

exit(1);

}

}

}

TransTableL::InitTT();

{

for (int c = 0; c < TT_TRICKS; c++)

{

for (int h = 0; h < DDS_HANDS; h++)

{

for (int i = 0; i < 256; i++)

{

TTroot[c][h][i].nextNo = 0;

TTroot[c][h][i].nextWriteNo = 0;

}

lastBlockSeen[c][h] = nullptr;

}

}

{

if (! TTInUse)

return;

TTInUse = 0;

for (int t = 0; t < TT_TRICKS; t++)

{

for (int h = 0; h < DDS_HANDS; h++)

{

if (TTroot[t][h] == nullptr)

continue;

free(TTroot[t][h]);

}

}

{

UNUSED(reason);

if (poolp == nullptr)

return;

pageStats.numResets++;

pageStats.numCallocs += pagesCurrent - pageStats.lastCurrent;

pageStats.lastCurrent = pagesCurrent;

while (pagesCurrent > pagesDefault)

{

free(poolp->list);

poolp = poolp->prev;

free(poolp->next);

poolp->next = nullptr;

pagesCurrent--;

}

pageStats.numFrees += pageStats.lastCurrent - pagesCurrent;

pageStats.lastCurrent = pagesCurrent;

while (poolp->prev)

poolp = poolp->prev;

poolp->nextBlockNo = 0;

nextBlockp = poolp->list;

TransTableL::InitTT();

timestamp = 0;

memState = FROM_POOL;

return;

{

poolType * tmp;

if (poolp)

{

while (poolp->next)

poolp = poolp->next;

while (poolp)

{

free(poolp->list);

tmp = poolp;

poolp = poolp->prev;

free(tmp);

}

}

pagesCurrent = 0;

pageStats.numResets = 0;

pageStats.numCallocs = 0;

pageStats.numFrees = 0;

pageStats.numHarvests = 0;

pageStats.lastCurrent = 0;

TransTableL::ReleaseTT();

return;

{

poolType * pp = poolp;

int count = 0;

do

{

count += pp->nextBlockNo;

pp = pp->prev;

}

while (pp);

return count;

{

int blockMem = BLOCKS_PER_PAGE * pagesCurrent *

static_cast<int>(sizeof(winBlockType));

int aggrMem = 8192 * static_cast<int>(sizeof(aggrType));

int rootMem = TT_TRICKS * DDS_HANDS * 256 *

static_cast<int>(sizeof(distHashType));

return (blockMem + aggrMem + rootMem) / static_cast<double>(1024.);

{

distHashType * rootptr = TTroot[harvestTrick][harvestHand];

distHashType * ptr;

winBlockType * bp;

int trick = harvestTrick;

int hand = harvestHand;

int hash, suit, hno = 0;

while (1)

{

for (hash = 0; hash < 256; hash++)

{

ptr = &rootptr[hash];

for (suit = ptr->nextNo - 1; suit >= 0; suit--)

{

bp = ptr->list[suit].posBlock;

if (timestamp - bp->timestampRead > HARVEST_AGE)

{

bp->nextMatchNo = 0;

bp->nextWriteNo = 0;

bp->timestampRead = timestamp;

harvested.list[hno] = bp;

// Swap the last element down.

if (suit != ptr->nextNo - 1)

ptr->list[suit] = ptr->list[ ptr->nextNo - 1 ];

ptr->nextNo--;

ptr->nextWriteNo = ptr->nextNo;

if (++hno == BLOCKS_PER_PAGE)

{

if (++harvestHand >= DDS_HANDS)

{

// Skip rest of this [trick][hand] for simplicity.

harvestHand = 0;

if (--harvestTrick < 0)

harvestTrick = FIRST_HARVEST_TRICK;

}

harvested.nextBlockNo = 0;

pageStats.numHarvests++;

return true;

}

}

}

}

if (++harvestHand >= DDS_HANDS)

{

harvestHand = 0;

if (--harvestTrick < 0)

harvestTrick = FIRST_HARVEST_TRICK;

}

if (harvestTrick == trick && harvestHand == hand)

return false;

rootptr = TTroot[harvestTrick][harvestHand];

}

{

/*

int h =

(handDist[0] ^

((handDist[1] * 5) ) ^

((handDist[2] * 25) ) ^

((handDist[3] * 125) ) );

return (h ^ (h >> 5)) & 0xff;

winBlockType * bp,

const winMatchType& search,

const bool flag)

{

// Either updates an existing SOP or creates a new one.

// A new one is created at the end of the bp list if this

// is not already full, or the oldest one in the list is

// overwritten.

winMatchType * wp = bp->list;

int n = bp->nextMatchNo;

for (int i = 0; i < n; i++, wp++)

{

if (wp->xorSet != search.xorSet ) continue;

if (wp->maskIndex != search.maskIndex) continue;

if (wp->topSet1 != search.topSet1 ) continue;

if (wp->topSet2 != search.topSet2 ) continue;

if (wp->topSet3 != search.topSet3 ) continue;

nodeCardsType& node = wp->first;

if (search.first.lbound > node.lbound)

node.lbound = search.first.lbound;

if (search.first.ubound < node.ubound)

node.ubound = search.first.ubound;

node.bestMoveSuit = search.first.bestMoveSuit;

node.bestMoveRank = search.first.bestMoveRank;

return;

}

if (n == BLOCKS_PER_ENTRY)

{

if (bp->nextWriteNo >= BLOCKS_PER_ENTRY)

bp->nextWriteNo = 0;

}

else

bp->nextMatchNo++;

wp = &bp->list[ bp->nextWriteNo++ ];

*wp = search;

if (!flag)

{

wp->first.bestMoveSuit = 0;

wp->first.bestMoveRank = 0;

}

const int tricks,

const int hand,

const unsigned short aggrTarget[],

const unsigned short ourWinRanks[],

const nodeCardsType& first,

const bool flag)

{

if (lastBlockSeen[tricks][hand] == nullptr)

{

// We have recently reset the entire memory, and we were

// in the middle of a recursion. So we'll just have to

// drop this entry that we were supposed to be adding.

return;

}

unsigned * ab[DDS_SUITS];

unsigned * mb[DDS_SUITS];

char low[DDS_SUITS];

unsigned short int ag;

int w;

winMatchType TTentry;

// Inefficient, as it also copies leastWin.

// In fact I'm not quite happy with the treatment of

// leastWin in general.

TTentry.first = first;

TTentry.xorSet = 0;

for (int ss = 0; ss < DDS_SUITS; ss++)

{

w = static_cast<int>(ourWinRanks[ss]);

if (w == 0)

{

ab[ss] = aggr[0].aggrBytes[ss];

mb[ss] = maskBytes[0][ss];

low[ss] = 15;

TTentry.first.leastWin[ss] = 0;

}

else

{

w = w & (-w); /* Only lowest win */

ag = static_cast<unsigned short>(aggrTarget[ss] & (-w));

ab[ss] = aggr[ag].aggrBytes[ss];

mb[ss] = maskBytes[ag][ss];

low[ss] = static_cast<char>(TTlowestRank[ag]);

TTentry.first.leastWin[ss] = 15 - low[ss];

TTentry.xorSet ^= aggr[ag].aggrRanks[ss];

}

}

// It's a bit annoying that we may be regenerating these.

// But winRanks can cause them to change after lookup().

TTentry.topSet1 = ab[0][0] | ab[1][0] | ab[2][0] | ab[3][0];

TTentry.topSet2 = ab[0][1] | ab[1][1] | ab[2][1] | ab[3][1];

TTentry.topSet3 = ab[0][2] | ab[1][2] | ab[2][2] | ab[3][2];

TTentry.topSet4 = ab[0][3] | ab[1][3] | ab[2][3] | ab[3][3];

TTentry.topMask1 = mb[0][0] | mb[1][0] | mb[2][0] | mb[3][0];

TTentry.topMask2 = mb[0][1] | mb[1][1] | mb[2][1] | mb[3][1];

TTentry.topMask3 = mb[0][2] | mb[1][2] | mb[2][2] | mb[3][2];

TTentry.topMask4 = mb[0][3] | mb[1][3] | mb[2][3] | mb[3][3];

TTentry.maskIndex =

(low[0] << 12) | (low[1] << 8) | (low[2] << 4) | low[3];

if (TTentry.topMask2 == 0)

TTentry.lastMaskNo = 1;

else if (TTentry.topMask3 == 0)

TTentry.lastMaskNo = 2;

else if (TTentry.topMask4 == 0)

TTentry.lastMaskNo = 3;

else

TTentry.lastMaskNo = 4;

TransTableL::CreateOrUpdate(lastBlockSeen[tricks][hand],

TTentry, flag);

ofstream& fout,

const winMatchType& wp,

const unsigned char lengths[DDS_HANDS][DDS_SUITS]) const

{