WLPaint::WLPaint()
{
int rndbits_x = log2_ceil(g_Image->width());
rndbits_y = log2_ceil(g_Image->height());
int rndbits = rndbits_x + rndbits_y;
if(rndbits < 17)
rndbits = 17; // no problem, just a bit slower
else if(rndbits > 25)
rndbits = 25; // fizzle fade will not fill whole screen
rndmask = rndmasks[rndbits - 17];
}
static void initChunksCommon()
{
#define ROUND_CHUNKS(a) a = (((a) + CHUNK_SIZE - 1) / CHUNK_SIZE) * CHUNK_SIZE;
int q;
if (CHUNK_SIZE != 1 << log2_ceil(CHUNK_SIZE)) {
do_log(L_ERROR, "CHUNK SIZE %d is not a power of two.\n",
CHUNK_SIZE);
exit(1);
}
ROUND_CHUNKS(chunkHighMark);
ROUND_CHUNKS(chunkCriticalMark);
ROUND_CHUNKS(chunkLowMark);
if (chunkHighMark < 8 * CHUNK_SIZE) {
int mem = physicalMemory();
if (mem > 0)
chunkHighMark = mem / 4;
else
chunkHighMark = 24 * MB;
chunkHighMark = MIN(chunkHighMark, 24 * MB);
chunkHighMark = MAX(chunkHighMark, 8 * CHUNK_SIZE);
}
if (chunkHighMark < MB / 2)
fprintf(stderr,
"Warning: little chunk memory (%d bytes)\n",
chunkHighMark);
q = 0;
if (chunkLowMark <= 0)
q = 1;
if (chunkLowMark < 4 * CHUNK_SIZE ||
chunkLowMark > chunkHighMark - 4 * CHUNK_SIZE) {
chunkLowMark = MIN(chunkHighMark - 4 * CHUNK_SIZE,
chunkHighMark * 3 / 4);
ROUND_CHUNKS(chunkLowMark);
if (!q)
do_log(L_WARN,
"Inconsistent chunkLowMark -- setting to %d.\n",
chunkLowMark);
}
q = 0;
if (chunkCriticalMark <= 0)
q = 1;
if (chunkCriticalMark >= chunkHighMark - 2 * CHUNK_SIZE ||
chunkCriticalMark <= chunkLowMark + 2 * CHUNK_SIZE) {
chunkCriticalMark =
MIN(chunkHighMark - 2 * CHUNK_SIZE,
chunkLowMark + (chunkHighMark -
chunkLowMark) * 15 / 16);
ROUND_CHUNKS(chunkCriticalMark);
if (!q)
do_log(L_WARN, "Inconsistent chunkCriticalMark -- "
"setting to %d.\n", chunkCriticalMark);
}
#undef ROUND_CHUNKS
}
void Analysis::add_compress_update(const entry_t& entry, bool analysis) {
// Add or update window information for analyzed entry.
if(analysis) {
auto &window = window_list[entry];
window.length = 1;
}
// decay_map[entry] = std::make_pair(true, 0);
for(auto w = window_list.begin(); w != window_list.end();) {
auto &owner = w->first;
auto &window = w->second;
// Don't add to window that starts with same entry.
if(owner == entry) {
++w;
continue;
}
window.length += 1;
wsize_t window_ind = log2_ceil(window.length);
singlFreq[entry][window_ind] += 1;
jointFreq[entry_pair_t(entry, owner)][window_ind] += 1;
if(window.length == max_fpdist + 1) {
w = window_list.erase(w);
} else {
++w;
}
}
}
static void cache_bios_region(void)
{
int mtrr;
uint32_t rom_size, alignment;
mtrr = get_free_var_mtrr();
if (mtrr==-1)
return;
/* Only the IFD BIOS region is memory mapped (at top of 4G) */
rom_size = CONFIG_IFD_BIOS_END - CONFIG_IFD_BIOS_START;
/* Round to power of two */
alignment = 1 << (log2_ceil(rom_size));
rom_size = ALIGN_UP(rom_size, alignment);
set_var_mtrr(mtrr, 4ULL*GiB - rom_size, rom_size, MTRR_TYPE_WRPROT);
}
void
initObject()
{
int q;
if(objectHighMark < 16) {
objectHighMark = 16;
do_log(L_WARN, "Impossibly low objectHighMark -- setting to %d.\n",
objectHighMark);
}
q = 0;
if(publicObjectLowMark == 0) q = 1;
if(publicObjectLowMark < 8 || publicObjectLowMark >= objectHighMark - 4) {
publicObjectLowMark = objectHighMark / 2;
if(!q)
do_log(L_WARN, "Impossible publicObjectLowMark value -- "
"setting to %d.\n", publicObjectLowMark);
}
q = 1;
if(objectHashTableSize <= objectHighMark / 2 ||
objectHashTableSize > objectHighMark * 1024) {
if(objectHashTableSize != 0) q = 0;
objectHashTableSize = objectHighMark * 16;
}
log2ObjectHashTableSize = log2_ceil(objectHashTableSize);
objectHashTableSize = 1 << log2ObjectHashTableSize;
if(!q)
do_log(L_WARN, "Suspicious objectHashTableSize value -- "
"setting to %d.\n", objectHashTableSize);
object_list = NULL;
object_list_end = NULL;
publicObjectCount = 0;
privateObjectCount = 0;
objectHashTable = calloc(1 << log2ObjectHashTableSize,
sizeof(ObjectPtr));
if(!objectHashTable) {
do_log(L_ERROR, "Couldn't allocate object hash table.\n");
exit(1);
}
}
void
generate_mod (int limb_bits, int nail_bits)
{
int numb_bits = limb_bits - nail_bits;
int i, divisor;
mpz_init_set_ui (pp, 0L);
mpz_init_set_ui (pp_norm, 0L);
mpz_init_set_ui (pp_inverted, 0L);
/* no more than limb_bits many factors in a one limb modulus (and of
course in reality nothing like that many) */
factor_alloc = limb_bits;
factor = xmalloc (factor_alloc * sizeof (*factor));
rawfactor = xmalloc (factor_alloc * sizeof (*rawfactor));
if (numb_bits % 4 != 0)
{
strcpy (mod34_excuse, "GMP_NUMB_BITS % 4 != 0");
goto use_pp;
}
max_divisor = 2*limb_bits;
max_divisor_bits = log2_ceil (max_divisor);
if (numb_bits / 4 < max_divisor_bits)
{
/* Wind back to one limb worth of max_divisor, if that will let us use
mpn_mod_34lsub1. */
max_divisor = limb_bits;
max_divisor_bits = log2_ceil (max_divisor);
if (numb_bits / 4 < max_divisor_bits)
{
strcpy (mod34_excuse, "GMP_NUMB_BITS / 4 too small");
goto use_pp;
}
}
{
/* Can use mpn_mod_34lsub1, find small factors of 2^mod34_bits-1. */
mpz_t m, q, r;
int multiplicity;
mod34_bits = (numb_bits / 4) * 3;
/* mpn_mod_34lsub1 returns a full limb value, PERFSQR_MOD_34 folds it at
the mod34_bits mark, adding the two halves for a remainder of at most
mod34_bits+1 many bits */
mod_bits = mod34_bits + 1;
mpz_init_set_ui (m, 1L);
mpz_mul_2exp (m, m, mod34_bits);
mpz_sub_ui (m, m, 1L);
mpz_init (q);
mpz_init (r);
for (i = 3; i <= max_divisor; i++)
{
if (! isprime (i))
continue;
mpz_tdiv_qr_ui (q, r, m, (unsigned long) i);
if (mpz_sgn (r) != 0)
continue;
/* if a repeated prime is found it's used as an i^n in one factor */
divisor = 1;
multiplicity = 0;
do
{
if (divisor > max_divisor / i)
break;
multiplicity++;
mpz_set (m, q);
mpz_tdiv_qr_ui (q, r, m, (unsigned long) i);
}
while (mpz_sgn (r) == 0);
assert (nrawfactor < factor_alloc);
rawfactor[nrawfactor].divisor = i;
rawfactor[nrawfactor].multiplicity = multiplicity;
nrawfactor++;
}
mpz_clear (m);
mpz_clear (q);
mpz_clear (r);
}
if (nrawfactor <= 2)
{
mpz_t new_pp;
sprintf (mod34_excuse, "only %d small factor%s",
nrawfactor, nrawfactor == 1 ? "" : "s");
use_pp:
/* reset to two limbs of max_divisor, in case the mpn_mod_34lsub1 code
tried with just one */
max_divisor = 2*limb_bits;
max_divisor_bits = log2_ceil (max_divisor);
mpz_init (new_pp);
nrawfactor = 0;
mod_bits = MIN (numb_bits, limb_bits - max_divisor_bits);
/* one copy of each small prime */
mpz_set_ui (pp, 1L);
for (i = 3; i <= max_divisor; i++)
{
if (! isprime (i))
continue;
mpz_mul_ui (new_pp, pp, (unsigned long) i);
if (mpz_sizeinbase (new_pp, 2) > mod_bits)
break;
mpz_set (pp, new_pp);
assert (nrawfactor < factor_alloc);
rawfactor[nrawfactor].divisor = i;
rawfactor[nrawfactor].multiplicity = 1;
nrawfactor++;
}
/* Plus an extra copy of one or more of the primes selected, if that
still fits in max_divisor and the total in mod_bits. Usually only
3 or 5 will be candidates */
for (i = nrawfactor-1; i >= 0; i--)
{
if (rawfactor[i].divisor > max_divisor / rawfactor[i].divisor)
continue;
mpz_mul_ui (new_pp, pp, (unsigned long) rawfactor[i].divisor);
if (mpz_sizeinbase (new_pp, 2) > mod_bits)
continue;
mpz_set (pp, new_pp);
rawfactor[i].multiplicity++;
}
mod_bits = mpz_sizeinbase (pp, 2);
mpz_set (pp_norm, pp);
while (mpz_sizeinbase (pp_norm, 2) < numb_bits)
mpz_add (pp_norm, pp_norm, pp_norm);
mpz_preinv_invert (pp_inverted, pp_norm, numb_bits);
mpz_clear (new_pp);
}
/* start the factor array */
for (i = 0; i < nrawfactor; i++)
{
int j;
assert (nfactor < factor_alloc);
factor[nfactor].divisor = 1;
for (j = 0; j < rawfactor[i].multiplicity; j++)
factor[nfactor].divisor *= rawfactor[i].divisor;
nfactor++;
}
combine:
/* Combine entries in the factor array. Combine the smallest entry with
the biggest one that will fit with it (ie. under max_divisor), then
repeat that with the new smallest entry. */
qsort (factor, nfactor, sizeof (factor[0]), f_cmp_divisor);
for (i = nfactor-1; i >= 1; i--)
{
if (factor[i].divisor <= max_divisor / factor[0].divisor)
{
factor[0].divisor *= factor[i].divisor;
COLLAPSE_ELEMENT (factor, i, nfactor);
goto combine;
}
}
total_fraction = 1.0;
for (i = 0; i < nfactor; i++)
{
mpz_init (factor[i].inverse);
mpz_invert_ui_2exp (factor[i].inverse,
(unsigned long) factor[i].divisor,
(unsigned long) mod_bits);
mpz_init (factor[i].mask);
square_mask (factor[i].mask, factor[i].divisor);
/* fraction of possible squares */
factor[i].fraction = (double) mpz_popcount (factor[i].mask)
/ factor[i].divisor;
/* total fraction of possible squares */
total_fraction *= factor[i].fraction;
}
/* best tests first (ie. smallest fraction) */
qsort (factor, nfactor, sizeof (factor[0]), f_cmp_fraction);
}
