int search_large(unsigned char *x, int m, unsigned char *y, int n, int q) {
unsigned int B[SIGMA], D, h, mm, tmp;
int i, j, count, p_len;
p_len = m;
m = 32;
BEGIN_PREPROCESSING
/* Preprocessing */
for (i = 0; i < SIGMA; ++i) B[i] = ~0;
h = mm = 0;
for (j = 0; j < q; ++j) {
for (i = 0; i < m/q; ++i) {
tmp = ~(1<<h);
B[x[i*q+j]] &= tmp;
++h;
}
mm |= (1<<(h-1));
}
END_PREPROCESSING
BEGIN_SEARCHING
/* Searching */
count = 0;
D = ~0;
j = 0;
while (j < n) {
D = ((D & ~mm)<<1)|B[y[j]];
if ((D & mm) != mm)
verify_large(y, j, n, x, m, q, D, mm, &count, p_len);
j += q;
}
END_SEARCHING
return count;
}
static void verify_swept (struct caml_heap_state* local) {
int i;
struct mem_stats pool_stats = {}, large_stats = {};
/* sweeping should be done by this point */
Assert(local->next_to_sweep == NUM_SIZECLASSES);
for (i = 0; i < NUM_SIZECLASSES; i++) {
Assert(local->unswept_avail_pools[i] == 0 &&
local->unswept_full_pools[i] == 0);
pool* p;
for (p = local->avail_pools[i]; p; p = p->next)
verify_pool(p, i, &pool_stats);
for (p = local->full_pools[i]; p; p = p->next) {
Assert(p->next_obj == 0);
verify_pool(p, i, &pool_stats);
}
}
caml_gc_log("Pooled memory: %lu alloced, %lu free, %lu fragmentation",
pool_stats.alloced, pool_stats.free, pool_stats.overhead);
verify_large(local->swept_large, &large_stats);
Assert(local->unswept_large == 0);
caml_gc_log("Large memory: %lu alloced, %lu free, %lu fragmentation",
large_stats.alloced, large_stats.free, large_stats.overhead);
/* Check stats are being computed correctly */
Assert(local->stats.pool_words == pool_stats.alloced);
Assert(local->stats.pool_live_words == pool_stats.live);
Assert(local->stats.pool_live_blocks == pool_stats.live_blocks);
Assert(local->stats.pool_frag_words == pool_stats.overhead);
Assert(local->stats.pool_words -
(local->stats.pool_live_words + local->stats.pool_frag_words)
== pool_stats.free);
Assert(local->stats.large_words == large_stats.alloced);
Assert(local->stats.large_blocks == large_stats.live_blocks);
}
