int handle_credfree(struct provmsg *msg, void *arg)
{
struct bitvec *alive = (struct bitvec *) arg;
if (!bitvec_test(alive, msg->cred_id))
printf("%x freed before fork!\n", msg->cred_id);
else
bitvec_clear(alive, msg->cred_id);
return 0;
}
int
main(int argc, char *argv[])
{
bitvec_t *bv;
int i, j;
clock_t c;
TEST_ASSERT(bv = bitvec_alloc(199));
bitvec_set(bv,198);
bitvec_set(bv,0);
bitvec_set(bv,42);
bitvec_set(bv,43);
bitvec_set(bv,44);
TEST_ASSERT(bitvec_is_set(bv,198));
TEST_ASSERT(bitvec_is_set(bv,0));
TEST_ASSERT(bitvec_is_set(bv,42));
TEST_ASSERT(bitvec_is_set(bv,43));
TEST_ASSERT(bitvec_is_set(bv,44));
TEST_EQUAL(5, bitvec_count_set(bv, 199));
bitvec_clear(bv, 43);
TEST_EQUAL(0, bitvec_is_set(bv,43));
c = clock();
for (j = 0; j < 1000000; ++j)
bitvec_count_set(bv, 199);
c = clock() - c;
printf("1000000 * 199 bitvec_count_set in %.2f sec\n",
(double)c / CLOCKS_PER_SEC);
bitvec_free(bv);
bv = bitvec_alloc(1314);
c = clock();
for (j = 0; j < 50000; ++j)
for (i = 0; i < 1314; ++i)
bitvec_set(bv, i);
c = clock() - c;
printf("50000 * 1314 bitvec_set in %.2f sec\n",
(double)c / CLOCKS_PER_SEC);
bitvec_free(bv);
/* Test realloc */
bv = bitvec_alloc(13);
for (i = 1; i < 13; i+=2)
bitvec_set(bv, i);
printf("Bits set %d\n", bitvec_count_set(bv, 13));
TEST_EQUAL(6, bitvec_count_set(bv, 13));
bv = bitvec_realloc(bv, 13, 2000);
for (i = 0; i < 2000; i++) {
/* printf("%d %d\n", i, bitvec_is_set(bv, i) != 0); */
}
printf("Bits set after realloc %d\n", bitvec_count_set(bv, 2000));
TEST_EQUAL(6, bitvec_count_set(bv, 2000));
bitvec_free(bv);
return 0;
}
int
test_bitvec_none_all(char ch)
{
Bitvec a;
bitvec_initbytes(&a, 1, &ch);
fprintf(stdout, "a: ");
bitvec_fprint(stdout, &a);
fprintf(stdout, "none1:%d all1:%d", bitvec_none1(&a), bitvec_all1(&a));
endline();
bitvec_clear(&a);
return 0;
}
int
test_1_bitvec(void)
{
Bitvec a, b, c;
bitvec_init(&a, 64);
bitvec_init(&b, 64);
bitvec_init(&c, 64);
bitvec_rand(&b);
fprintf(stdout, "b: ");
bitvec_fprint(stdout, &b);
puts("");
bitvec_rand(&c);
fprintf(stdout, "c: ");
bitvec_fprint(stdout, &c);
puts("");
bitvec_uniform_crossover(&a, &b, &c);
fprintf(stdout, "a: ");
bitvec_fprint(stdout, &a);
puts("");
bitvec_rev(&a, &a);
fprintf(stdout, "a: ");
bitvec_fprint(stdout, &a);
puts("");
bitvec_rev(&a, &a);
fprintf(stdout, "a: ");
bitvec_fprint(stdout, &a);
puts("");
bitvec_clear(&a);
bitvec_clear(&b);
bitvec_clear(&c);
return 0;
}
subvq_t *subvq_init (char *file)
{
FILE *fp;
char line[16384];
int32 n_sv;
int32 s, k, n, r, c;
char *strp;
subvq_t *vq;
E_INFO("Loading Mixture Gaussian sub-VQ file '%s'\n", file);
vq = (subvq_t *) ckd_calloc (1, sizeof(subvq_t));
fp = myfopen(file, "r");
/* Read until "Sub-vectors" */
for (;;) {
if (fgets (line, sizeof(line), fp) == NULL)
E_FATAL("Failed to read VQParam header\n");
if (sscanf (line, "VQParam %d %d -> %d %d",
&(vq->origsize.r), &(vq->origsize.c), &(vq->n_sv), &(vq->vqsize)) == 4)
break;
}
n_sv = vq->n_sv;
vq->svsize = (int32 *) ckd_calloc (n_sv, sizeof(int32));
vq->featdim = (int32 **) ckd_calloc (n_sv, sizeof(int32 *));
vq->mean = (float32 ***) ckd_calloc (n_sv, sizeof(float32 **));
vq->var = (float32 ***) ckd_calloc (n_sv, sizeof(float32 **));
vq->map = (int32 ***) ckd_calloc_3d (vq->origsize.r, vq->origsize.c, n_sv, sizeof(int32));
vq->cb_invalid = bitvec_alloc (vq->origsize.r);
/* Read subvector sizes and feature dimension maps */
for (s = 0; s < n_sv; s++) {
if ((fgets (line, sizeof(line), fp) == NULL) ||
(sscanf (line, "Subvector %d length %d%n", &k, &(vq->svsize[s]), &n) != 2) ||
(k != s))
E_FATAL("Error reading length(subvector %d)\n", s);
vq->mean[s] = (float32 **) ckd_calloc_2d (vq->vqsize, vq->svsize[s], sizeof(float32));
vq->var[s] = (float32 **) ckd_calloc_2d (vq->vqsize, vq->svsize[s], sizeof(float32));
vq->featdim[s] = (int32 *) ckd_calloc (vq->svsize[s], sizeof(int32));
for (strp = line+n, c = 0; c < vq->svsize[s]; c++) {
if (sscanf (strp, "%d%n", &(vq->featdim[s][c]), &n) != 1)
E_FATAL("Error reading subvector(%d).featdim(%d)\n", s, c);
strp += n;
}
}
/* Echo info for sanity check */
E_INFO("Original #codebooks(states)/codewords: %d x %d\n", vq->origsize.r, vq->origsize.c);
E_INFO("Subvectors: %d, VQsize: %d\n", vq->n_sv, vq->vqsize);
for (s = 0; s < n_sv; s++) {
E_INFO("Feature dims(%d): ", s);
for (c = 0; c < vq->svsize[s]; c++)
printf (" %2d", vq->featdim[s][c]);
printf (" (%d)\n", vq->svsize[s]);
}
/* Read VQ codebooks and maps for each subvector */
for (s = 0; s < n_sv; s++) {
E_INFO("Reading subvq %d\n", s);
E_INFO("Reading codebook\n");
if ((fgets (line, sizeof(line), fp) == NULL) ||
(sscanf (line, "Codebook %d", &k) != 1) || (k != s))
E_FATAL("Error reading header\n", s);
for (r = 0; r < vq->vqsize; r++) {
if (fgets (line, sizeof(line), fp) == NULL)
E_FATAL("Error reading row(%d)\n", r);
for (strp = line, c = 0; c < vq->svsize[s]; c++) {
if (sscanf (strp, "%f %f%n", &(vq->mean[s][r][c]), &(vq->var[s][r][c]), &k) != 2)
E_FATAL("Error reading row(%d) col(%d)\n", r, c);
strp += k;
}
}
#if 0
E_INFO("Sanity check: mean[0,%d]:\n", vq->vqsize-1);
vector_print (stdout, vq->mean[s][0], vq->svsize[s]);
vector_print (stdout, vq->mean[s][vq->vqsize-1], vq->svsize[s]);
E_INFO("Sanity check: var[0,%d]:\n", vq->vqsize-1);
vector_print (stdout, vq->var[s][0], vq->svsize[s]);
vector_print (stdout, vq->var[s][vq->vqsize-1], vq->svsize[s]);
#endif
E_INFO("Reading map\n");
if ((fgets (line, sizeof(line), fp) == NULL) ||
(sscanf (line, "Map %d", &k) != 1) || (k != s))
E_FATAL("Error reading header\n", s);
for (r = 0; r < vq->origsize.r; r++) {
if (fgets (line, sizeof(line), fp) == NULL)
E_FATAL("Error reading row(%d)\n", r);
for (strp = line, c = 0; c < vq->origsize.c; c++) {
if (sscanf (strp, "%d%n", &(vq->map[r][c][s]), &k) != 1)
E_FATAL("Error reading row(%d) col(%d)\n", r, c);
strp += k;
}
}
#if 0
E_INFO("Sanity check: map[0][0]:\n");
for (c = 0; c < vq->origsize.c; c++)
printf (" %d", vq->map[0][c][s]);
printf ("\n");
#endif
fflush (stdout);
}
if ((fscanf (fp, "%s", line) != 1) || (strcmp (line, "End") != 0))
E_FATAL("Error reading 'End' token\n");
fclose (fp);
subvq_ivar_idet_precompute (vq, 0.0001 /* varfloor */);
#if 0
E_INFO("Sanity check: var[*,0]:\n");
for (s = 0; s < n_sv; s++)
vector_print (stdout, vq->var[s][0], vq->svsize[s]);
#endif
/* Replace invalid entries in map with duplicate of a valid entry, if possible */
for (r = 0; r < vq->origsize.r; r++) {
k = -1;
for (c = 0; c < vq->origsize.c; c++) {
if (vq->map[r][c][0] < 0) {
/* All ought to be < 0 */
for (s = 1; s < vq->n_sv; s++) {
if (vq->map[r][c][s] >= 0)
E_FATAL("Partially undefined map[%d][%d]\n", r, c);
}
} else {
/* All ought to be >= 0 */
for (s = 1; s < vq->n_sv; s++) {
if (vq->map[r][c][s] < 0)
E_FATAL("Partially undefined map[%d][%d]\n", r, c);
}
k = c; /* A valid codeword found; remember it */
}
}
if (k >= 0) {
/* Copy k into invalid rows */
for (c = 0; c < vq->origsize.c; c++) {
if (vq->map[r][c][0] < 0) {
for (s = 0; s < vq->n_sv; s++)
vq->map[r][c][s] = vq->map[r][k][s];
}
}
bitvec_clear (vq->cb_invalid, r);
} else
bitvec_set (vq->cb_invalid, r);
}
return vq;
}
