select data structure added
This commit is contained in:
fc_botelho
parent
042ff338c3
commit
579487c5cf
|
|
@ -1,26 +1,13 @@
|
|||
bin_PROGRAMS = cmph
|
||||
lib_LTLIBRARIES = libcmph.la
|
||||
include_HEADERS = cmph.h cmph_types.h
|
||||
libcmph_la_SOURCES = debug.h\
|
||||
bitbool.h\
|
||||
cmph_types.h\
|
||||
hash.h hash_state.h hash.c\
|
||||
jenkins_hash.h jenkins_hash.c\
|
||||
vstack.h vstack.c\
|
||||
vqueue.h vqueue.c\
|
||||
graph.h graph.c\
|
||||
cmph.h cmph.c\
|
||||
cmph_structs.h cmph_structs.c\
|
||||
chm.h chm_structs.h chm.c\
|
||||
bmz.h bmz_structs.h bmz.c\
|
||||
bmz8.h bmz8_structs.h bmz8.c\
|
||||
bdz.h bdz_structs.h bdz.c\
|
||||
bdz_ph.h bdz_structs_ph.h bdz_ph.c\
|
||||
buffer_manager.h buffer_manager.c\
|
||||
buffer_entry.h buffer_entry.c\
|
||||
brz.h brz_structs.h brz.c\
|
||||
fch.h fch_structs.h fch.c\
|
||||
fch_buckets.h fch_buckets.c
|
||||
libcmph_la_SOURCES = hash.c jenkins_hash.c\
|
||||
vstack.c vqueue.c\
|
||||
graph.c cmph.c cmph_structs.c\
|
||||
chm.c bmz.c bmz8.c bdz.c bdz_ph.c\
|
||||
buffer_manager.c buffer_entry.c\
|
||||
brz.c fch.c fch_buckets.c \
|
||||
select.c
|
||||
|
||||
libcmph_la_LDFLAGS = -version-info 0:0:0
|
||||
|
||||
|
|
|
|||
42
src/bdz.c
42
src/bdz.c
|
|
@ -468,27 +468,28 @@ int bdz_dump(cmph_t *mphf, FILE *fd)
|
|||
{
|
||||
char *buf = NULL;
|
||||
cmph_uint32 buflen;
|
||||
register cmph_uint32 nbytes;
|
||||
bdz_data_t *data = (bdz_data_t *)mphf->data;
|
||||
__cmph_dump(mphf, fd);
|
||||
|
||||
hash_state_dump(data->hl, &buf, &buflen);
|
||||
DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
|
||||
fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
free(buf);
|
||||
|
||||
fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(&(data->r), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->r), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
|
||||
cmph_uint32 sizeg = ceil(data->n/4.0);
|
||||
fwrite(data->g, sizeof(cmph_uint8)*sizeg, (size_t)1, fd);
|
||||
nbytes = fwrite(data->g, sizeof(cmph_uint8)*sizeg, (size_t)1, fd);
|
||||
|
||||
fwrite(&(data->k), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(&(data->b), sizeof(cmph_uint8), (size_t)1, fd);
|
||||
fwrite(&(data->ranktablesize), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->k), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->b), sizeof(cmph_uint8), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->ranktablesize), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
|
||||
fwrite(data->ranktable, sizeof(cmph_uint32)*(data->ranktablesize), (size_t)1, fd);
|
||||
nbytes = fwrite(data->ranktable, sizeof(cmph_uint32)*(data->ranktablesize), (size_t)1, fd);
|
||||
#ifdef DEBUG
|
||||
cmph_uint32 i;
|
||||
fprintf(stderr, "G: ");
|
||||
|
|
@ -502,33 +503,34 @@ void bdz_load(FILE *f, cmph_t *mphf)
|
|||
{
|
||||
char *buf = NULL;
|
||||
cmph_uint32 buflen, sizeg;
|
||||
register cmph_uint32 nbytes;
|
||||
bdz_data_t *bdz = (bdz_data_t *)malloc(sizeof(bdz_data_t));
|
||||
|
||||
DEBUGP("Loading bdz mphf\n");
|
||||
mphf->data = bdz;
|
||||
|
||||
fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
DEBUGP("Hash state has %u bytes\n", buflen);
|
||||
buf = (char *)malloc((size_t)buflen);
|
||||
fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
bdz->hl = hash_state_load(buf, buflen);
|
||||
free(buf);
|
||||
|
||||
|
||||
DEBUGP("Reading m and n\n");
|
||||
fread(&(bdz->n), sizeof(cmph_uint32), (size_t)1, f);
|
||||
fread(&(bdz->m), sizeof(cmph_uint32), (size_t)1, f);
|
||||
fread(&(bdz->r), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(bdz->n), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(bdz->m), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(bdz->r), sizeof(cmph_uint32), (size_t)1, f);
|
||||
sizeg = ceil(bdz->n/4.0);
|
||||
bdz->g = (cmph_uint8 *)calloc((size_t)(sizeg), sizeof(cmph_uint8));
|
||||
fread(bdz->g, sizeg*sizeof(cmph_uint8), (size_t)1, f);
|
||||
nbytes = fread(bdz->g, sizeg*sizeof(cmph_uint8), (size_t)1, f);
|
||||
|
||||
fread(&(bdz->k), sizeof(cmph_uint32), (size_t)1, f);
|
||||
fread(&(bdz->b), sizeof(cmph_uint8), (size_t)1, f);
|
||||
fread(&(bdz->ranktablesize), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(bdz->k), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(bdz->b), sizeof(cmph_uint8), (size_t)1, f);
|
||||
nbytes = fread(&(bdz->ranktablesize), sizeof(cmph_uint32), (size_t)1, f);
|
||||
|
||||
bdz->ranktable = (cmph_uint32 *)calloc((size_t)bdz->ranktablesize, sizeof(cmph_uint32));
|
||||
fread(bdz->ranktable, sizeof(cmph_uint32)*(bdz->ranktablesize), (size_t)1, f);
|
||||
nbytes = fread(bdz->ranktable, sizeof(cmph_uint32)*(bdz->ranktablesize), (size_t)1, f);
|
||||
|
||||
#ifdef DEBUG
|
||||
cmph_uint32 i = 0;
|
||||
|
|
|
|||
26
src/bdz_ph.c
26
src/bdz_ph.c
|
|
@ -432,20 +432,21 @@ int bdz_ph_dump(cmph_t *mphf, FILE *fd)
|
|||
char *buf = NULL;
|
||||
cmph_uint32 buflen;
|
||||
cmph_uint32 sizeg = 0;
|
||||
register cmph_uint32 nbytes;
|
||||
bdz_ph_data_t *data = (bdz_ph_data_t *)mphf->data;
|
||||
__cmph_dump(mphf, fd);
|
||||
|
||||
hash_state_dump(data->hl, &buf, &buflen);
|
||||
DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
|
||||
fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
free(buf);
|
||||
|
||||
fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(&(data->r), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->r), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
sizeg = ceil(data->n/5.0);
|
||||
fwrite(data->g, sizeof(cmph_uint8)*sizeg, (size_t)1, fd);
|
||||
nbytes = fwrite(data->g, sizeof(cmph_uint8)*sizeg, (size_t)1, fd);
|
||||
|
||||
#ifdef DEBUG
|
||||
cmph_uint32 i;
|
||||
|
|
@ -461,26 +462,27 @@ void bdz_ph_load(FILE *f, cmph_t *mphf)
|
|||
char *buf = NULL;
|
||||
cmph_uint32 buflen;
|
||||
cmph_uint32 sizeg = 0;
|
||||
register cmph_uint32 nbytes;
|
||||
bdz_ph_data_t *bdz_ph = (bdz_ph_data_t *)malloc(sizeof(bdz_ph_data_t));
|
||||
|
||||
DEBUGP("Loading bdz_ph mphf\n");
|
||||
mphf->data = bdz_ph;
|
||||
|
||||
fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
DEBUGP("Hash state has %u bytes\n", buflen);
|
||||
buf = (char *)malloc((size_t)buflen);
|
||||
fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
bdz_ph->hl = hash_state_load(buf, buflen);
|
||||
free(buf);
|
||||
|
||||
|
||||
DEBUGP("Reading m and n\n");
|
||||
fread(&(bdz_ph->n), sizeof(cmph_uint32), (size_t)1, f);
|
||||
fread(&(bdz_ph->m), sizeof(cmph_uint32), (size_t)1, f);
|
||||
fread(&(bdz_ph->r), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(bdz_ph->n), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(bdz_ph->m), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(bdz_ph->r), sizeof(cmph_uint32), (size_t)1, f);
|
||||
sizeg = ceil(bdz_ph->n/5.0);
|
||||
bdz_ph->g = (cmph_uint8 *)calloc((size_t)sizeg, sizeof(cmph_uint8));
|
||||
fread(bdz_ph->g, sizeg*sizeof(cmph_uint8), (size_t)1, f);
|
||||
nbytes = fread(bdz_ph->g, sizeg*sizeof(cmph_uint8), (size_t)1, f);
|
||||
|
||||
/* #ifdef DEBUG
|
||||
cmph_uint32 i;
|
||||
|
|
|
|||
31
src/bmz.c
31
src/bmz.c
|
|
@ -448,26 +448,27 @@ int bmz_dump(cmph_t *mphf, FILE *fd)
|
|||
cmph_uint32 buflen;
|
||||
cmph_uint32 two = 2; //number of hash functions
|
||||
bmz_data_t *data = (bmz_data_t *)mphf->data;
|
||||
register cmph_uint32 nbytes;
|
||||
__cmph_dump(mphf, fd);
|
||||
|
||||
fwrite(&two, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&two, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
|
||||
hash_state_dump(data->hashes[0], &buf, &buflen);
|
||||
DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
|
||||
fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
free(buf);
|
||||
|
||||
hash_state_dump(data->hashes[1], &buf, &buflen);
|
||||
DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
|
||||
fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
free(buf);
|
||||
|
||||
fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
|
||||
fwrite(data->g, sizeof(cmph_uint32)*(data->n), (size_t)1, fd);
|
||||
nbytes = fwrite(data->g, sizeof(cmph_uint32)*(data->n), (size_t)1, fd);
|
||||
#ifdef DEBUG
|
||||
cmph_uint32 i;
|
||||
fprintf(stderr, "G: ");
|
||||
|
|
@ -484,31 +485,31 @@ void bmz_load(FILE *f, cmph_t *mphf)
|
|||
cmph_uint32 buflen;
|
||||
cmph_uint32 i;
|
||||
bmz_data_t *bmz = (bmz_data_t *)malloc(sizeof(bmz_data_t));
|
||||
|
||||
register cmph_uint32 nbytes;
|
||||
DEBUGP("Loading bmz mphf\n");
|
||||
mphf->data = bmz;
|
||||
fread(&nhashes, sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&nhashes, sizeof(cmph_uint32), (size_t)1, f);
|
||||
bmz->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(nhashes + 1));
|
||||
bmz->hashes[nhashes] = NULL;
|
||||
DEBUGP("Reading %u hashes\n", nhashes);
|
||||
for (i = 0; i < nhashes; ++i)
|
||||
{
|
||||
hash_state_t *state = NULL;
|
||||
fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
DEBUGP("Hash state has %u bytes\n", buflen);
|
||||
buf = (char *)malloc((size_t)buflen);
|
||||
fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
state = hash_state_load(buf, buflen);
|
||||
bmz->hashes[i] = state;
|
||||
free(buf);
|
||||
}
|
||||
|
||||
DEBUGP("Reading m and n\n");
|
||||
fread(&(bmz->n), sizeof(cmph_uint32), (size_t)1, f);
|
||||
fread(&(bmz->m), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(bmz->n), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(bmz->m), sizeof(cmph_uint32), (size_t)1, f);
|
||||
|
||||
bmz->g = (cmph_uint32 *)malloc(sizeof(cmph_uint32)*bmz->n);
|
||||
fread(bmz->g, bmz->n*sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(bmz->g, bmz->n*sizeof(cmph_uint32), (size_t)1, f);
|
||||
#ifdef DEBUG
|
||||
fprintf(stderr, "G: ");
|
||||
for (i = 0; i < bmz->n; ++i) fprintf(stderr, "%u ", bmz->g[i]);
|
||||
|
|
|
|||
30
src/bmz8.c
30
src/bmz8.c
|
|
@ -458,26 +458,27 @@ int bmz8_dump(cmph_t *mphf, FILE *fd)
|
|||
cmph_uint32 buflen;
|
||||
cmph_uint8 two = 2; //number of hash functions
|
||||
bmz8_data_t *data = (bmz8_data_t *)mphf->data;
|
||||
register cmph_uint32 nbytes;
|
||||
__cmph_dump(mphf, fd);
|
||||
|
||||
fwrite(&two, sizeof(cmph_uint8), (size_t)1, fd);
|
||||
nbytes = fwrite(&two, sizeof(cmph_uint8), (size_t)1, fd);
|
||||
|
||||
hash_state_dump(data->hashes[0], &buf, &buflen);
|
||||
DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
|
||||
fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
free(buf);
|
||||
|
||||
hash_state_dump(data->hashes[1], &buf, &buflen);
|
||||
DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
|
||||
fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
free(buf);
|
||||
|
||||
fwrite(&(data->n), sizeof(cmph_uint8), (size_t)1, fd);
|
||||
fwrite(&(data->m), sizeof(cmph_uint8), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->n), sizeof(cmph_uint8), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->m), sizeof(cmph_uint8), (size_t)1, fd);
|
||||
|
||||
fwrite(data->g, sizeof(cmph_uint8)*(data->n), (size_t)1, fd);
|
||||
nbytes = fwrite(data->g, sizeof(cmph_uint8)*(data->n), (size_t)1, fd);
|
||||
#ifdef DEBUG
|
||||
fprintf(stderr, "G: ");
|
||||
for (i = 0; i < data->n; ++i) fprintf(stderr, "%u ", data->g[i]);
|
||||
|
|
@ -492,32 +493,33 @@ void bmz8_load(FILE *f, cmph_t *mphf)
|
|||
char *buf = NULL;
|
||||
cmph_uint32 buflen;
|
||||
cmph_uint8 i;
|
||||
register cmph_uint32 nbytes;
|
||||
bmz8_data_t *bmz8 = (bmz8_data_t *)malloc(sizeof(bmz8_data_t));
|
||||
|
||||
DEBUGP("Loading bmz8 mphf\n");
|
||||
mphf->data = bmz8;
|
||||
fread(&nhashes, sizeof(cmph_uint8), (size_t)1, f);
|
||||
nbytes = fread(&nhashes, sizeof(cmph_uint8), (size_t)1, f);
|
||||
bmz8->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(nhashes + 1));
|
||||
bmz8->hashes[nhashes] = NULL;
|
||||
DEBUGP("Reading %u hashes\n", nhashes);
|
||||
for (i = 0; i < nhashes; ++i)
|
||||
{
|
||||
hash_state_t *state = NULL;
|
||||
fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
DEBUGP("Hash state has %u bytes\n", buflen);
|
||||
buf = (char *)malloc((size_t)buflen);
|
||||
fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
state = hash_state_load(buf, buflen);
|
||||
bmz8->hashes[i] = state;
|
||||
free(buf);
|
||||
}
|
||||
|
||||
DEBUGP("Reading m and n\n");
|
||||
fread(&(bmz8->n), sizeof(cmph_uint8), (size_t)1, f);
|
||||
fread(&(bmz8->m), sizeof(cmph_uint8), (size_t)1, f);
|
||||
nbytes = fread(&(bmz8->n), sizeof(cmph_uint8), (size_t)1, f);
|
||||
nbytes = fread(&(bmz8->m), sizeof(cmph_uint8), (size_t)1, f);
|
||||
|
||||
bmz8->g = (cmph_uint8 *)malloc(sizeof(cmph_uint8)*bmz8->n);
|
||||
fread(bmz8->g, bmz8->n*sizeof(cmph_uint8), (size_t)1, f);
|
||||
nbytes = fread(bmz8->g, bmz8->n*sizeof(cmph_uint8), (size_t)1, f);
|
||||
#ifdef DEBUG
|
||||
fprintf(stderr, "G: ");
|
||||
for (i = 0; i < bmz8->n; ++i) fprintf(stderr, "%u ", bmz8->g[i]);
|
||||
|
|
|
|||
55
src/brz.c
55
src/brz.c
|
|
@ -227,6 +227,7 @@ static int brz_gen_mphf(cmph_config_t *mph)
|
|||
cmph_uint32 *buffer_h0 = NULL;
|
||||
cmph_uint32 nflushes = 0;
|
||||
cmph_uint32 h0;
|
||||
register cmph_uint32 nbytes;
|
||||
FILE * tmp_fd = NULL;
|
||||
buffer_manager_t * buff_manager = NULL;
|
||||
char *filename = NULL;
|
||||
|
|
@ -280,7 +281,7 @@ static int brz_gen_mphf(cmph_config_t *mph)
|
|||
for(i = 0; i < nkeys_in_buffer; i++)
|
||||
{
|
||||
memcpy(&keylen1, buffer + keys_index[i], sizeof(keylen1));
|
||||
fwrite(buffer + keys_index[i], (size_t)1, keylen1 + sizeof(keylen1), tmp_fd);
|
||||
nbytes = fwrite(buffer + keys_index[i], (size_t)1, keylen1 + sizeof(keylen1), tmp_fd);
|
||||
}
|
||||
nkeys_in_buffer = 0;
|
||||
memory_usage = 0;
|
||||
|
|
@ -340,7 +341,7 @@ static int brz_gen_mphf(cmph_config_t *mph)
|
|||
for(i = 0; i < nkeys_in_buffer; i++)
|
||||
{
|
||||
memcpy(&keylen1, buffer + keys_index[i], sizeof(keylen1));
|
||||
fwrite(buffer + keys_index[i], (size_t)1, keylen1 + sizeof(keylen1), tmp_fd);
|
||||
nbytes = fwrite(buffer + keys_index[i], (size_t)1, keylen1 + sizeof(keylen1), tmp_fd);
|
||||
}
|
||||
nkeys_in_buffer = 0;
|
||||
memory_usage = 0;
|
||||
|
|
@ -359,12 +360,12 @@ static int brz_gen_mphf(cmph_config_t *mph)
|
|||
fprintf(stderr, "\nMPHF generation \n");
|
||||
}
|
||||
/* Starting to dump to disk the resultant MPHF: __cmph_dump function */
|
||||
fwrite(cmph_names[CMPH_BRZ], (size_t)(strlen(cmph_names[CMPH_BRZ]) + 1), (size_t)1, brz->mphf_fd);
|
||||
fwrite(&(brz->m), sizeof(brz->m), (size_t)1, brz->mphf_fd);
|
||||
fwrite(&(brz->c), sizeof(double), (size_t)1, brz->mphf_fd);
|
||||
fwrite(&(brz->algo), sizeof(brz->algo), (size_t)1, brz->mphf_fd);
|
||||
fwrite(&(brz->k), sizeof(cmph_uint32), (size_t)1, brz->mphf_fd); // number of MPHFs
|
||||
fwrite(brz->size, sizeof(cmph_uint8)*(brz->k), (size_t)1, brz->mphf_fd);
|
||||
nbytes = fwrite(cmph_names[CMPH_BRZ], (size_t)(strlen(cmph_names[CMPH_BRZ]) + 1), (size_t)1, brz->mphf_fd);
|
||||
nbytes = fwrite(&(brz->m), sizeof(brz->m), (size_t)1, brz->mphf_fd);
|
||||
nbytes = fwrite(&(brz->c), sizeof(double), (size_t)1, brz->mphf_fd);
|
||||
nbytes = fwrite(&(brz->algo), sizeof(brz->algo), (size_t)1, brz->mphf_fd);
|
||||
nbytes = fwrite(&(brz->k), sizeof(cmph_uint32), (size_t)1, brz->mphf_fd); // number of MPHFs
|
||||
nbytes = fwrite(brz->size, sizeof(cmph_uint8)*(brz->k), (size_t)1, brz->mphf_fd);
|
||||
|
||||
//tmp_fds = (FILE **)calloc(nflushes, sizeof(FILE *));
|
||||
buff_manager = buffer_manager_new(brz->memory_availability, nflushes);
|
||||
|
|
@ -473,7 +474,7 @@ static int brz_gen_mphf(cmph_config_t *mph)
|
|||
break;
|
||||
default: assert(0);
|
||||
}
|
||||
fwrite(bufmphf, (size_t)buflenmphf, (size_t)1, brz->mphf_fd);
|
||||
nbytes = fwrite(bufmphf, (size_t)buflenmphf, (size_t)1, brz->mphf_fd);
|
||||
free(bufmphf);
|
||||
bufmphf = NULL;
|
||||
cmph_config_destroy(config);
|
||||
|
|
@ -557,17 +558,18 @@ int brz_dump(cmph_t *mphf, FILE *fd)
|
|||
brz_data_t *data = (brz_data_t *)mphf->data;
|
||||
char *buf = NULL;
|
||||
cmph_uint32 buflen;
|
||||
register cmph_uint32 nbytes;
|
||||
DEBUGP("Dumping brzf\n");
|
||||
// The initial part of the MPHF have already been dumped to disk during construction
|
||||
// Dumping h0
|
||||
hash_state_dump(data->h0, &buf, &buflen);
|
||||
DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
|
||||
fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
free(buf);
|
||||
// Dumping m and the vector offset.
|
||||
fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(data->offset, sizeof(cmph_uint32)*(data->k), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(data->offset, sizeof(cmph_uint32)*(data->k), (size_t)1, fd);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
@ -575,16 +577,17 @@ void brz_load(FILE *f, cmph_t *mphf)
|
|||
{
|
||||
char *buf = NULL;
|
||||
cmph_uint32 buflen;
|
||||
register cmph_uint32 nbytes;
|
||||
cmph_uint32 i, n;
|
||||
brz_data_t *brz = (brz_data_t *)malloc(sizeof(brz_data_t));
|
||||
|
||||
DEBUGP("Loading brz mphf\n");
|
||||
mphf->data = brz;
|
||||
fread(&(brz->c), sizeof(double), (size_t)1, f);
|
||||
fread(&(brz->algo), sizeof(brz->algo), (size_t)1, f); // Reading algo.
|
||||
fread(&(brz->k), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(brz->c), sizeof(double), (size_t)1, f);
|
||||
nbytes = fread(&(brz->algo), sizeof(brz->algo), (size_t)1, f); // Reading algo.
|
||||
nbytes = fread(&(brz->k), sizeof(cmph_uint32), (size_t)1, f);
|
||||
brz->size = (cmph_uint8 *) malloc(sizeof(cmph_uint8)*brz->k);
|
||||
fread(brz->size, sizeof(cmph_uint8)*(brz->k), (size_t)1, f);
|
||||
nbytes = fread(brz->size, sizeof(cmph_uint8)*(brz->k), (size_t)1, f);
|
||||
brz->h1 = (hash_state_t **)malloc(sizeof(hash_state_t *)*brz->k);
|
||||
brz->h2 = (hash_state_t **)malloc(sizeof(hash_state_t *)*brz->k);
|
||||
brz->g = (cmph_uint8 **) calloc((size_t)brz->k, sizeof(cmph_uint8 *));
|
||||
|
|
@ -593,17 +596,17 @@ void brz_load(FILE *f, cmph_t *mphf)
|
|||
for(i = 0; i < brz->k; i++)
|
||||
{
|
||||
// h1
|
||||
fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
DEBUGP("Hash state 1 has %u bytes\n", buflen);
|
||||
buf = (char *)malloc((size_t)buflen);
|
||||
fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
brz->h1[i] = hash_state_load(buf, buflen);
|
||||
free(buf);
|
||||
//h2
|
||||
fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
DEBUGP("Hash state 2 has %u bytes\n", buflen);
|
||||
buf = (char *)malloc((size_t)buflen);
|
||||
fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
brz->h2[i] = hash_state_load(buf, buflen);
|
||||
free(buf);
|
||||
switch(brz->algo)
|
||||
|
|
@ -618,20 +621,20 @@ void brz_load(FILE *f, cmph_t *mphf)
|
|||
}
|
||||
DEBUGP("g_i has %u bytes\n", n);
|
||||
brz->g[i] = (cmph_uint8 *)calloc((size_t)n, sizeof(cmph_uint8));
|
||||
fread(brz->g[i], sizeof(cmph_uint8)*n, (size_t)1, f);
|
||||
nbytes = fread(brz->g[i], sizeof(cmph_uint8)*n, (size_t)1, f);
|
||||
}
|
||||
//loading h0
|
||||
fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
DEBUGP("Hash state has %u bytes\n", buflen);
|
||||
buf = (char *)malloc((size_t)buflen);
|
||||
fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
brz->h0 = hash_state_load(buf, buflen);
|
||||
free(buf);
|
||||
|
||||
//loading c, m, and the vector offset.
|
||||
fread(&(brz->m), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(brz->m), sizeof(cmph_uint32), (size_t)1, f);
|
||||
brz->offset = (cmph_uint32 *)malloc(sizeof(cmph_uint32)*brz->k);
|
||||
fread(brz->offset, sizeof(cmph_uint32)*(brz->k), (size_t)1, f);
|
||||
nbytes = fread(brz->offset, sizeof(cmph_uint32)*(brz->k), (size_t)1, f);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
|||
32
src/chm.c
32
src/chm.c
|
|
@ -204,25 +204,27 @@ int chm_dump(cmph_t *mphf, FILE *fd)
|
|||
cmph_uint32 buflen;
|
||||
cmph_uint32 two = 2; //number of hash functions
|
||||
chm_data_t *data = (chm_data_t *)mphf->data;
|
||||
register cmph_uint32 nbytes;
|
||||
|
||||
__cmph_dump(mphf, fd);
|
||||
|
||||
fwrite(&two, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&two, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
hash_state_dump(data->hashes[0], &buf, &buflen);
|
||||
DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
|
||||
fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
free(buf);
|
||||
|
||||
hash_state_dump(data->hashes[1], &buf, &buflen);
|
||||
DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
|
||||
fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
free(buf);
|
||||
|
||||
fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
|
||||
fwrite(data->g, sizeof(cmph_uint32)*data->n, (size_t)1, fd);
|
||||
nbytes = fwrite(data->g, sizeof(cmph_uint32)*data->n, (size_t)1, fd);
|
||||
#ifdef DEBUG
|
||||
fprintf(stderr, "G: ");
|
||||
for (i = 0; i < data->n; ++i) fprintf(stderr, "%u ", data->g[i]);
|
||||
|
|
@ -238,31 +240,31 @@ void chm_load(FILE *f, cmph_t *mphf)
|
|||
cmph_uint32 buflen;
|
||||
cmph_uint32 i;
|
||||
chm_data_t *chm = (chm_data_t *)malloc(sizeof(chm_data_t));
|
||||
|
||||
register cmph_uint32 nbytes;
|
||||
DEBUGP("Loading chm mphf\n");
|
||||
mphf->data = chm;
|
||||
fread(&nhashes, sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&nhashes, sizeof(cmph_uint32), (size_t)1, f);
|
||||
chm->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(nhashes + 1));
|
||||
chm->hashes[nhashes] = NULL;
|
||||
DEBUGP("Reading %u hashes\n", nhashes);
|
||||
for (i = 0; i < nhashes; ++i)
|
||||
{
|
||||
hash_state_t *state = NULL;
|
||||
fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
DEBUGP("Hash state has %u bytes\n", buflen);
|
||||
buf = (char *)malloc((size_t)buflen);
|
||||
fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
state = hash_state_load(buf, buflen);
|
||||
chm->hashes[i] = state;
|
||||
free(buf);
|
||||
}
|
||||
|
||||
DEBUGP("Reading m and n\n");
|
||||
fread(&(chm->n), sizeof(cmph_uint32), (size_t)1, f);
|
||||
fread(&(chm->m), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(chm->n), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(chm->m), sizeof(cmph_uint32), (size_t)1, f);
|
||||
|
||||
chm->g = (cmph_uint32 *)malloc(sizeof(cmph_uint32)*chm->n);
|
||||
fread(chm->g, chm->n*sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(chm->g, chm->n*sizeof(cmph_uint32), (size_t)1, f);
|
||||
#ifdef DEBUG
|
||||
fprintf(stderr, "G: ");
|
||||
for (i = 0; i < chm->n; ++i) fprintf(stderr, "%u ", chm->g[i]);
|
||||
|
|
|
|||
|
|
@ -150,11 +150,12 @@ static void key_vector_rewind(void *data)
|
|||
static cmph_uint32 count_nlfile_keys(FILE *fd)
|
||||
{
|
||||
cmph_uint32 count = 0;
|
||||
register char * ptr;
|
||||
rewind(fd);
|
||||
while(1)
|
||||
{
|
||||
char buf[BUFSIZ];
|
||||
fgets(buf, BUFSIZ, fd);
|
||||
ptr = fgets(buf, BUFSIZ, fd);
|
||||
if (feof(fd)) break;
|
||||
if (buf[strlen(buf) - 1] != '\n') continue;
|
||||
++count;
|
||||
|
|
|
|||
|
|
@ -24,8 +24,9 @@ void __config_destroy(cmph_config_t *mph)
|
|||
|
||||
void __cmph_dump(cmph_t *mphf, FILE *fd)
|
||||
{
|
||||
fwrite(cmph_names[mphf->algo], (size_t)(strlen(cmph_names[mphf->algo]) + 1), (size_t)1, fd);
|
||||
fwrite(&(mphf->size), sizeof(mphf->size), (size_t)1, fd);
|
||||
register cmph_uint32 nbytes;
|
||||
nbytes = fwrite(cmph_names[mphf->algo], (size_t)(strlen(cmph_names[mphf->algo]) + 1), (size_t)1, fd);
|
||||
nbytes = fwrite(&(mphf->size), sizeof(mphf->size), (size_t)1, fd);
|
||||
}
|
||||
cmph_t *__cmph_load(FILE *f)
|
||||
{
|
||||
|
|
@ -34,7 +35,8 @@ cmph_t *__cmph_load(FILE *f)
|
|||
char algo_name[BUFSIZ];
|
||||
char *ptr = algo_name;
|
||||
CMPH_ALGO algo = CMPH_COUNT;
|
||||
|
||||
register cmph_uint32 nbytes;
|
||||
|
||||
DEBUGP("Loading mphf\n");
|
||||
while(1)
|
||||
{
|
||||
|
|
@ -57,7 +59,7 @@ cmph_t *__cmph_load(FILE *f)
|
|||
}
|
||||
mphf = (cmph_t *)malloc(sizeof(cmph_t));
|
||||
mphf->algo = algo;
|
||||
fread(&(mphf->size), sizeof(mphf->size), (size_t)1, f);
|
||||
nbytes = fread(&(mphf->size), sizeof(mphf->size), (size_t)1, f);
|
||||
mphf->data = NULL;
|
||||
DEBUGP("Algorithm is %s and mphf is sized %u\n", cmph_names[algo], mphf->size);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,8 +1,13 @@
|
|||
#ifndef __CMPH_TYPES_H__
|
||||
#define __CMPH_TYPES_H__
|
||||
|
||||
typedef char cmph_int8;
|
||||
typedef unsigned char cmph_uint8;
|
||||
|
||||
typedef short cmph_int16;
|
||||
typedef unsigned short cmph_uint16;
|
||||
|
||||
typedef int cmph_int32;
|
||||
typedef unsigned int cmph_uint32;
|
||||
|
||||
#if defined(__ia64) || defined(__x86_64__)
|
||||
|
|
|
|||
43
src/fch.c
43
src/fch.c
|
|
@ -316,27 +316,29 @@ int fch_dump(cmph_t *mphf, FILE *fd)
|
|||
{
|
||||
char *buf = NULL;
|
||||
cmph_uint32 buflen;
|
||||
register cmph_uint32 nbytes;
|
||||
|
||||
fch_data_t *data = (fch_data_t *)mphf->data;
|
||||
__cmph_dump(mphf, fd);
|
||||
|
||||
hash_state_dump(data->h1, &buf, &buflen);
|
||||
//DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
|
||||
fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
free(buf);
|
||||
|
||||
hash_state_dump(data->h2, &buf, &buflen);
|
||||
//DEBUGP("Dumping hash state with %u bytes to disk\n", buflen);
|
||||
fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(buf, (size_t)buflen, (size_t)1, fd);
|
||||
free(buf);
|
||||
|
||||
fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(&(data->c), sizeof(double), (size_t)1, fd);
|
||||
fwrite(&(data->b), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
fwrite(&(data->p1), sizeof(double), (size_t)1, fd);
|
||||
fwrite(&(data->p2), sizeof(double), (size_t)1, fd);
|
||||
fwrite(data->g, sizeof(cmph_uint32)*(data->b), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->c), sizeof(double), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->b), sizeof(cmph_uint32), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->p1), sizeof(double), (size_t)1, fd);
|
||||
nbytes = fwrite(&(data->p2), sizeof(double), (size_t)1, fd);
|
||||
nbytes = fwrite(data->g, sizeof(cmph_uint32)*(data->b), (size_t)1, fd);
|
||||
#ifdef DEBUG
|
||||
cmph_uint32 i;
|
||||
fprintf(stderr, "G: ");
|
||||
|
|
@ -350,16 +352,17 @@ void fch_load(FILE *f, cmph_t *mphf)
|
|||
{
|
||||
char *buf = NULL;
|
||||
cmph_uint32 buflen;
|
||||
register cmph_uint32 nbytes;
|
||||
fch_data_t *fch = (fch_data_t *)malloc(sizeof(fch_data_t));
|
||||
|
||||
//DEBUGP("Loading fch mphf\n");
|
||||
mphf->data = fch;
|
||||
//DEBUGP("Reading h1\n");
|
||||
fch->h1 = NULL;
|
||||
fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
//DEBUGP("Hash state of h1 has %u bytes\n", buflen);
|
||||
buf = (char *)malloc((size_t)buflen);
|
||||
fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
fch->h1 = hash_state_load(buf, buflen);
|
||||
free(buf);
|
||||
|
||||
|
|
@ -367,23 +370,23 @@ void fch_load(FILE *f, cmph_t *mphf)
|
|||
mphf->data = fch;
|
||||
//DEBUGP("Reading h2\n");
|
||||
fch->h2 = NULL;
|
||||
fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&buflen, sizeof(cmph_uint32), (size_t)1, f);
|
||||
//DEBUGP("Hash state of h2 has %u bytes\n", buflen);
|
||||
buf = (char *)malloc((size_t)buflen);
|
||||
fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
nbytes = fread(buf, (size_t)buflen, (size_t)1, f);
|
||||
fch->h2 = hash_state_load(buf, buflen);
|
||||
free(buf);
|
||||
|
||||
|
||||
//DEBUGP("Reading m and n\n");
|
||||
fread(&(fch->m), sizeof(cmph_uint32), (size_t)1, f);
|
||||
fread(&(fch->c), sizeof(double), (size_t)1, f);
|
||||
fread(&(fch->b), sizeof(cmph_uint32), (size_t)1, f);
|
||||
fread(&(fch->p1), sizeof(double), (size_t)1, f);
|
||||
fread(&(fch->p2), sizeof(double), (size_t)1, f);
|
||||
nbytes = fread(&(fch->m), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(fch->c), sizeof(double), (size_t)1, f);
|
||||
nbytes = fread(&(fch->b), sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(&(fch->p1), sizeof(double), (size_t)1, f);
|
||||
nbytes = fread(&(fch->p2), sizeof(double), (size_t)1, f);
|
||||
|
||||
fch->g = (cmph_uint32 *)malloc(sizeof(cmph_uint32)*fch->b);
|
||||
fread(fch->g, fch->b*sizeof(cmph_uint32), (size_t)1, f);
|
||||
nbytes = fread(fch->g, fch->b*sizeof(cmph_uint32), (size_t)1, f);
|
||||
#ifdef DEBUG
|
||||
cmph_uint32 i;
|
||||
fprintf(stderr, "G: ");
|
||||
|
|
|
|||
|
|
@ -199,7 +199,7 @@ static int find_degree1_edge(graph_t *g, cmph_uint32 v, char *deleted, cmph_uint
|
|||
static void cyclic_del_edge(graph_t *g, cmph_uint32 v, char *deleted)
|
||||
{
|
||||
|
||||
cmph_uint32 e;
|
||||
cmph_uint32 e = 0;
|
||||
char degree1;
|
||||
cmph_uint32 v1 = v;
|
||||
cmph_uint32 v2 = 0;
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ void jenkins_state_destroy(jenkins_state_t *state);
|
|||
*/
|
||||
void jenkins_state_pack(jenkins_state_t *state, void *jenkins_packed);
|
||||
|
||||
/** \fn cmph_uint32 jenkins_state_packed_size(jenkins_state_t *state);
|
||||
/** \fn cmph_uint32 jenkins_state_packed_size();
|
||||
* \brief Return the amount of space needed to pack a jenkins function.
|
||||
* \return the size of the packed function or zero for failures
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -0,0 +1,327 @@
|
|||
#include<stdlib.h>
|
||||
#include<stdio.h>
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <limits.h>
|
||||
#include "select_lookup_tables.h"
|
||||
#include "select.h"
|
||||
|
||||
//#define DEBUG
|
||||
#include "debug.h"
|
||||
|
||||
#ifndef STEP_SELECT_TABLE
|
||||
#define STEP_SELECT_TABLE 128
|
||||
#endif
|
||||
|
||||
#ifndef NBITS_STEP_SELECT_TABLE
|
||||
#define NBITS_STEP_SELECT_TABLE 7
|
||||
#endif
|
||||
|
||||
#ifndef MASK_STEP_SELECT_TABLE
|
||||
#define MASK_STEP_SELECT_TABLE 0x7f // 0x7f = 127
|
||||
#endif
|
||||
|
||||
static inline void select_insert_0(cmph_uint32 * buffer)
|
||||
{
|
||||
(*buffer) >>= 1;
|
||||
};
|
||||
|
||||
static inline void select_insert_1(cmph_uint32 * buffer)
|
||||
{
|
||||
(*buffer) >>= 1;
|
||||
(*buffer) |= 0x80000000;
|
||||
};
|
||||
|
||||
void select_init(select_t * sel, cmph_uint32 n, cmph_uint32 m)
|
||||
{
|
||||
register cmph_uint32 nbits;
|
||||
register cmph_uint32 vec_size;
|
||||
register cmph_uint32 sel_table_size;
|
||||
sel->n = n;
|
||||
sel->m = m; // n values in the range [0,m-1]
|
||||
|
||||
nbits = sel->n + sel->m;
|
||||
vec_size = (nbits + 31) >> 5; // (nbits + 31) >> 5 = (nbits + 31)/32
|
||||
|
||||
sel_table_size = (sel->n >> NBITS_STEP_SELECT_TABLE) + 1; // (sel->n >> NBITS_STEP_SELECT_TABLE) = (sel->n/STEP_SELECT_TABLE)
|
||||
|
||||
sel->bits_vec = (cmph_uint32 *)calloc(vec_size, sizeof(cmph_uint32));
|
||||
|
||||
sel->select_table = (cmph_uint32 *)calloc(sel_table_size, sizeof(cmph_uint32));
|
||||
};
|
||||
|
||||
double select_get_space_usage(select_t * sel)
|
||||
{
|
||||
register cmph_uint32 nbits;
|
||||
register cmph_uint32 vec_size;
|
||||
register cmph_uint32 sel_table_size;
|
||||
register double space_usage;
|
||||
|
||||
nbits = sel->n + sel->m;
|
||||
vec_size = (nbits + 31) >> 5; // (nbits + 31) >> 5 = (nbits + 31)/32
|
||||
sel_table_size = (sel->n >> NBITS_STEP_SELECT_TABLE) + 1; // (sel->n >> NBITS_STEP_SELECT_TABLE) = (sel->n/STEP_SELECT_TABLE)
|
||||
|
||||
space_usage = 2 * sizeof(cmph_uint32) * 8; // n and m
|
||||
space_usage += vec_size * sizeof(cmph_uint32) * 8;
|
||||
space_usage += sel_table_size * sizeof(cmph_uint32) * 8;
|
||||
return space_usage;
|
||||
}
|
||||
|
||||
void select_destroy(select_t * sel)
|
||||
{
|
||||
free(sel->bits_vec);
|
||||
free(sel->select_table);
|
||||
sel->bits_vec = 0;
|
||||
sel->select_table = 0;
|
||||
};
|
||||
|
||||
static inline void select_generate_sel_table(select_t * sel)
|
||||
{
|
||||
register cmph_uint8 * bits_table = (cmph_uint8 *)sel->bits_vec;
|
||||
register cmph_uint32 part_sum, old_part_sum;
|
||||
register cmph_uint32 vec_idx, one_idx, sel_table_idx;
|
||||
|
||||
part_sum = vec_idx = one_idx = sel_table_idx = 0;
|
||||
|
||||
for(;;)
|
||||
{
|
||||
// FABIANO: Should'n it be one_idx >= sel->n
|
||||
if(one_idx >= sel->n)
|
||||
break;
|
||||
do
|
||||
{
|
||||
old_part_sum = part_sum;
|
||||
part_sum += rank_lookup_table[bits_table[vec_idx]];
|
||||
vec_idx++;
|
||||
} while (part_sum <= one_idx);
|
||||
|
||||
sel->select_table[sel_table_idx] = select_lookup_table[bits_table[vec_idx - 1]][one_idx - old_part_sum] + ((vec_idx - 1) << 3); // ((vec_idx - 1) << 3) = ((vec_idx - 1) * 8)
|
||||
one_idx += STEP_SELECT_TABLE ;
|
||||
sel_table_idx++;
|
||||
};
|
||||
};
|
||||
|
||||
void select_generate(select_t * sel, cmph_uint32 * keys_vec)
|
||||
{
|
||||
register cmph_uint32 i, j, idx;
|
||||
cmph_uint32 buffer = 0;
|
||||
|
||||
idx = i = j = 0;
|
||||
|
||||
for(;;)
|
||||
{
|
||||
while(keys_vec[j]==i)
|
||||
{
|
||||
select_insert_1(&buffer);
|
||||
idx++;
|
||||
|
||||
if((idx & 0x1f) == 0 ) // (idx & 0x1f) = idx % 32
|
||||
sel->bits_vec[(idx >> 5) - 1] = buffer; // (idx >> 5) = idx/32
|
||||
j++;
|
||||
|
||||
if(j == sel->n)
|
||||
goto loop_end;
|
||||
|
||||
//assert(keys_vec[j] < keys_vec[j-1]);
|
||||
}
|
||||
|
||||
if(i == sel->m)
|
||||
break;
|
||||
|
||||
while(keys_vec[j] > i)
|
||||
{
|
||||
select_insert_0(&buffer);
|
||||
idx++;
|
||||
|
||||
if((idx & 0x1f) == 0 ) // (idx & 0x1f) = idx % 32
|
||||
sel->bits_vec[(idx >> 5) - 1] = buffer; // (idx >> 5) = idx/32
|
||||
i++;
|
||||
};
|
||||
|
||||
};
|
||||
loop_end:
|
||||
if((idx & 0x1f) != 0 ) // (idx & 0x1f) = idx % 32
|
||||
{
|
||||
buffer >>= 32 - (idx & 0x1f);
|
||||
sel->bits_vec[ (idx - 1) >> 5 ] = buffer;
|
||||
};
|
||||
|
||||
select_generate_sel_table(sel);
|
||||
};
|
||||
|
||||
static inline cmph_int32 _select_query(cmph_uint8 * bits_table, cmph_uint32 * select_table, cmph_uint32 one_idx)
|
||||
{
|
||||
register cmph_uint32 vec_bit_idx ,vec_byte_idx;
|
||||
register cmph_uint32 part_sum, old_part_sum;
|
||||
|
||||
vec_bit_idx = select_table[one_idx >> NBITS_STEP_SELECT_TABLE]; // one_idx >> NBITS_STEP_SELECT_TABLE = one_idx/STEP_SELECT_TABLE
|
||||
vec_byte_idx = vec_bit_idx >> 3; // vec_bit_idx / 8
|
||||
|
||||
one_idx &= MASK_STEP_SELECT_TABLE; // one_idx %= STEP_SELECT_TABLE == one_idx &= MASK_STEP_SELECT_TABLE
|
||||
one_idx += rank_lookup_table[bits_table[vec_byte_idx] & ((1 << (vec_bit_idx & 0x7)) - 1)];
|
||||
part_sum = 0;
|
||||
|
||||
do
|
||||
{
|
||||
old_part_sum = part_sum;
|
||||
part_sum += rank_lookup_table[bits_table[vec_byte_idx]];
|
||||
vec_byte_idx++;
|
||||
|
||||
}while (part_sum <= one_idx);
|
||||
|
||||
return select_lookup_table[bits_table[vec_byte_idx - 1]][one_idx - old_part_sum] + ((vec_byte_idx-1) << 3);
|
||||
}
|
||||
|
||||
cmph_int32 select_query(select_t * sel, cmph_uint32 one_idx)
|
||||
{
|
||||
return _select_query((cmph_uint8 *)sel->bits_vec, sel->select_table, one_idx);
|
||||
};
|
||||
|
||||
|
||||
static inline cmph_int32 _select_next_query(cmph_uint8 * bits_table, cmph_uint32 vec_bit_idx)
|
||||
{
|
||||
register cmph_uint32 vec_byte_idx, one_idx;
|
||||
register cmph_uint32 part_sum, old_part_sum;
|
||||
|
||||
vec_byte_idx = vec_bit_idx >> 3;
|
||||
|
||||
one_idx = rank_lookup_table[bits_table[vec_byte_idx] & ((1 << (vec_bit_idx & 0x7)) - 1)] + 1;
|
||||
part_sum = 0;
|
||||
|
||||
do
|
||||
{
|
||||
old_part_sum = part_sum;
|
||||
part_sum += rank_lookup_table[bits_table[vec_byte_idx]];
|
||||
vec_byte_idx++;
|
||||
|
||||
}while (part_sum <= one_idx);
|
||||
|
||||
return select_lookup_table[bits_table[(vec_byte_idx - 1)]][(one_idx - old_part_sum)] + ((vec_byte_idx - 1) << 3);
|
||||
}
|
||||
|
||||
cmph_int32 select_next_query(select_t * sel, cmph_uint32 vec_bit_idx)
|
||||
{
|
||||
return _select_next_query((cmph_uint8 *)sel->bits_vec, vec_bit_idx);
|
||||
};
|
||||
|
||||
|
||||
void select_dump(select_t *sel, char **buf, cmph_uint32 *buflen)
|
||||
{
|
||||
register cmph_uint32 nbits = sel->n + sel->m;
|
||||
register cmph_uint32 vec_size = (nbits + 31) >> 5; // (nbits + 31) >> 5 = (nbits + 31)/32
|
||||
register cmph_uint32 sel_table_size = (sel->n >> NBITS_STEP_SELECT_TABLE) + 1; // (sel->n >> NBITS_STEP_SELECT_TABLE) = (sel->n/STEP_SELECT_TABLE)
|
||||
register cmph_uint32 pos = 0;
|
||||
|
||||
*buflen = 2*sizeof(cmph_uint32) + vec_size + sel_table_size;
|
||||
|
||||
*buf = (char *)calloc(*buflen, sizeof(char));
|
||||
|
||||
if (!*buf)
|
||||
{
|
||||
*buflen = UINT_MAX;
|
||||
return;
|
||||
}
|
||||
|
||||
memcpy(*buf, &(sel->n), sizeof(cmph_uint32));
|
||||
pos += sizeof(cmph_uint32);
|
||||
memcpy(*buf + pos, &(sel->m), sizeof(cmph_uint32));
|
||||
pos += sizeof(cmph_uint32);
|
||||
memcpy(*buf + pos, sel->bits_vec, vec_size);
|
||||
pos += vec_size;
|
||||
memcpy(*buf + pos, sel->select_table, sel_table_size);
|
||||
|
||||
DEBUGP("Dumped select structure with size %u bytes\n", *buflen);
|
||||
}
|
||||
|
||||
void select_load(select_t * sel, const char *buf, cmph_uint32 buflen)
|
||||
{
|
||||
register cmph_uint32 pos = 0;
|
||||
register cmph_uint32 nbits = 0;
|
||||
register cmph_uint32 vec_size = 0;
|
||||
register cmph_uint32 sel_table_size = 0;
|
||||
|
||||
memcpy(&(sel->n), buf, sizeof(cmph_uint32));
|
||||
pos += sizeof(cmph_uint32);
|
||||
memcpy(&(sel->m), buf + pos, sizeof(cmph_uint32));
|
||||
pos += sizeof(cmph_uint32);
|
||||
|
||||
nbits = sel->n + sel->m;
|
||||
vec_size = (nbits + 31) >> 5; // (nbits + 31) >> 5 = (nbits + 31)/32
|
||||
sel_table_size = (sel->n >> NBITS_STEP_SELECT_TABLE) + 1; // (sel->n >> NBITS_STEP_SELECT_TABLE) = (sel->n/STEP_SELECT_TABLE)
|
||||
|
||||
if(sel->bits_vec) free(sel->bits_vec);
|
||||
sel->bits_vec = (cmph_uint32 *)calloc(vec_size, sizeof(cmph_uint32));
|
||||
|
||||
if(sel->select_table) free(sel->select_table);
|
||||
sel->select_table = (cmph_uint32 *)calloc(sel_table_size, sizeof(cmph_uint32));
|
||||
|
||||
memcpy(sel->bits_vec, buf + pos, vec_size);
|
||||
pos += vec_size;
|
||||
memcpy(sel->select_table, buf + pos, sel_table_size);
|
||||
|
||||
DEBUGP("Loaded select structure with size %u bytes\n", buflen);
|
||||
}
|
||||
|
||||
|
||||
/** \fn void select_pack(select_t *sel, void *sel_packed);
|
||||
* \brief Support the ability to pack a select structure function into a preallocated contiguous memory space pointed by sel_packed.
|
||||
* \param sel points to the select structure
|
||||
* \param sel_packed pointer to the contiguous memory area used to store the select structure. The size of sel_packed must be at least @see select_packed_size
|
||||
*/
|
||||
void select_pack(select_t *sel, void *sel_packed)
|
||||
{
|
||||
if (sel && sel_packed)
|
||||
{
|
||||
char *buf = NULL;
|
||||
cmph_uint32 buflen = 0;
|
||||
select_dump(sel, &buf, &buflen);
|
||||
memcpy(sel_packed, buf, buflen);
|
||||
free(buf);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/** \fn cmph_uint32 select_packed_size(select_t *sel);
|
||||
* \brief Return the amount of space needed to pack a select structure.
|
||||
* \return the size of the packed select structure or zero for failures
|
||||
*/
|
||||
cmph_uint32 select_packed_size(select_t *sel)
|
||||
{
|
||||
register cmph_uint32 nbits = sel->n + sel->m;
|
||||
register cmph_uint32 vec_size = (nbits + 31) >> 5; // (nbits + 31) >> 5 = (nbits + 31)/32
|
||||
register cmph_uint32 sel_table_size = (sel->n >> NBITS_STEP_SELECT_TABLE) + 1; // (sel->n >> NBITS_STEP_SELECT_TABLE) = (sel->n/STEP_SELECT_TABLE)
|
||||
return 2*sizeof(cmph_uint32) + vec_size + sel_table_size;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/** \fn cmph_int32 select_query_packed(void * sel_packed, cmph_uint32 idx);
|
||||
* \param sel_packed is a pointer to a contiguous memory area
|
||||
* \param idx is the rank for which we want to calculate the inverse function select
|
||||
* \return an integer that represents the select value of rank idx.
|
||||
*/
|
||||
cmph_int32 select_query_packed(void * sel_packed, cmph_uint32 one_idx)
|
||||
{
|
||||
register cmph_uint32 *ptr = (cmph_uint32 *)sel_packed;
|
||||
register cmph_uint32 n = *ptr++;
|
||||
register cmph_uint32 m = *ptr++;
|
||||
register cmph_uint32 nbits = n + m;
|
||||
register cmph_uint32 vec_size = (nbits + 31) >> 5; // (nbits + 31) >> 5 = (nbits + 31)/32
|
||||
register cmph_uint8 * bits_vec = (cmph_uint8 *)ptr;
|
||||
register cmph_uint32 * select_table = ptr + vec_size;
|
||||
|
||||
return _select_query(bits_vec, select_table, one_idx);
|
||||
}
|
||||
|
||||
|
||||
/** \fn cmph_int32 select_next_query_packed(void * sel_packed, cmph_uint32 vec_bit_idx);
|
||||
* \param sel_packed is a pointer to a contiguous memory area
|
||||
* \param vec_bit_idx is a value prior computed by @see select_query_packed
|
||||
* \return an integer that represents the next select value greater than @see vec_bit_idx.
|
||||
*/
|
||||
cmph_int32 select_next_query_packed(void * sel_packed, cmph_uint32 vec_bit_idx)
|
||||
{
|
||||
register cmph_uint8 * bits_vec = (cmph_uint8 *)sel_packed;
|
||||
bits_vec += 8; // skipping n and m
|
||||
return _select_next_query(bits_vec, vec_bit_idx);
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
#ifndef SELECT_h
|
||||
#define SELECT_h
|
||||
|
||||
#include "cmph_types.h"
|
||||
|
||||
struct _select_t
|
||||
{
|
||||
cmph_uint32 n,m;
|
||||
cmph_uint32 * bits_vec;
|
||||
cmph_uint32 * select_table;
|
||||
};
|
||||
|
||||
typedef struct _select_t select_t;
|
||||
|
||||
void select_init(select_t * sel, cmph_uint32 n, cmph_uint32 m);
|
||||
|
||||
void select_destroy(select_t * sel);
|
||||
|
||||
void select_generate(select_t * sel, cmph_uint32 * keys_vec);
|
||||
|
||||
cmph_int32 select_query(select_t * sel, cmph_uint32 one_idx);
|
||||
|
||||
cmph_int32 select_next_query(select_t * sel, cmph_uint32 vec_bit_idx);
|
||||
|
||||
double select_get_space_usage(select_t * sel);
|
||||
|
||||
void select_dump(select_t *sel, char **buf, cmph_uint32 *buflen);
|
||||
|
||||
void select_load(select_t * sel, const char *buf, cmph_uint32 buflen);
|
||||
|
||||
|
||||
/** \fn void select_pack(select_t *sel, void *sel_packed);
|
||||
* \brief Support the ability to pack a select structure function into a preallocated contiguous memory space pointed by sel_packed.
|
||||
* \param sel points to the select structure
|
||||
* \param sel_packed pointer to the contiguous memory area used to store the select structure. The size of sel_packed must be at least @see select_packed_size
|
||||
*/
|
||||
void select_pack(select_t *sel, void *sel_packed);
|
||||
|
||||
/** \fn cmph_uint32 select_packed_size(select_t *sel);
|
||||
* \brief Return the amount of space needed to pack a select structure.
|
||||
* \return the size of the packed select structure or zero for failures
|
||||
*/
|
||||
cmph_uint32 select_packed_size(select_t *sel);
|
||||
|
||||
|
||||
/** \fn cmph_int32 select_query_packed(void * sel_packed, cmph_uint32 idx);
|
||||
* \param sel_packed is a pointer to a contiguous memory area
|
||||
* \param one_idx is the rank for which we want to calculate the inverse function select
|
||||
* \return an integer that represents the select value of rank idx.
|
||||
*/
|
||||
cmph_int32 select_query_packed(void * sel_packed, cmph_uint32 one_idx);
|
||||
|
||||
|
||||
/** \fn cmph_int32 select_next_query_packed(void * sel_packed, cmph_uint32 vec_bit_idx);
|
||||
* \param sel_packed is a pointer to a contiguous memory area
|
||||
* \param vec_bit_idx is a value prior computed by @see select_query_packed
|
||||
* \return an integer that represents the next select value greater than @see vec_bit_idx.
|
||||
*/
|
||||
cmph_int32 select_next_query_packed(void * sel_packed, cmph_uint32 vec_bit_idx);
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,170 @@
|
|||
#ifndef SELECT_LOOKUP_TABLES
|
||||
#define SELECT_LOOKUP_TABLES
|
||||
|
||||
#include "cmph_types.h"
|
||||
|
||||
/*
|
||||
rank_lookup_table[i] simply gives the number of bits set to one in the byte of value i.
|
||||
For example if i = 01010101 in binary then we have :
|
||||
rank_lookup_table[i] = 4
|
||||
*/
|
||||
|
||||
static cmph_uint8 rank_lookup_table[256] ={
|
||||
0 , 1 , 1 , 2 , 1 , 2 , 2 , 3 , 1 , 2 , 2 , 3 , 2 , 3 , 3 , 4
|
||||
, 1 , 2 , 2 , 3 , 2 , 3 , 3 , 4 , 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5
|
||||
, 1 , 2 , 2 , 3 , 2 , 3 , 3 , 4 , 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5
|
||||
, 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6
|
||||
, 1 , 2 , 2 , 3 , 2 , 3 , 3 , 4 , 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5
|
||||
, 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6
|
||||
, 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6
|
||||
, 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6 , 4 , 5 , 5 , 6 , 5 , 6 , 6 , 7
|
||||
, 1 , 2 , 2 , 3 , 2 , 3 , 3 , 4 , 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5
|
||||
, 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6
|
||||
, 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6
|
||||
, 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6 , 4 , 5 , 5 , 6 , 5 , 6 , 6 , 7
|
||||
, 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6
|
||||
, 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6 , 4 , 5 , 5 , 6 , 5 , 6 , 6 , 7
|
||||
, 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6 , 4 , 5 , 5 , 6 , 5 , 6 , 6 , 7
|
||||
, 4 , 5 , 5 , 6 , 5 , 6 , 6 , 7 , 5 , 6 , 6 , 7 , 6 , 7 , 7 , 8
|
||||
};
|
||||
|
||||
/*
|
||||
select_lookup_table[i][j] simply gives the index of the j'th bit set to one in the byte of value i.
|
||||
For example if i=01010101 in binary then we have :
|
||||
select_lookup_table[i][0] = 0, the first bit set to one is at position 0
|
||||
select_lookup_table[i][1] = 2, the second bit set to one is at position 2
|
||||
select_lookup_table[i][2] = 4, the third bit set to one is at position 4
|
||||
select_lookup_table[i][3] = 6, the fourth bit set to one is at position 6
|
||||
select_lookup_table[i][4] = 255, there is no more than 4 bits set to one in i, so we return escape value 255.
|
||||
*/
|
||||
static cmph_uint8 select_lookup_table[256][8]={
|
||||
{ 255 , 255 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 255 , 255 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 255 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 255 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 255 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 255 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 3 , 255 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 3 , 255 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 3 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 3 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 3 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 3 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 3 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 3 , 255 , 255 , 255 , 255 } ,
|
||||
{ 4 , 255 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 4 , 255 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 4 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 4 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 4 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 4 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 4 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 4 , 255 , 255 , 255 , 255 } ,
|
||||
{ 3 , 4 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 3 , 4 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 3 , 4 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 3 , 4 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 3 , 4 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 3 , 4 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 3 , 4 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 3 , 4 , 255 , 255 , 255 } ,
|
||||
{ 5 , 255 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 5 , 255 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 5 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 5 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 5 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 5 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 5 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 5 , 255 , 255 , 255 , 255 } ,
|
||||
{ 3 , 5 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 3 , 5 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 3 , 5 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 3 , 5 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 3 , 5 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 3 , 5 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 3 , 5 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 3 , 5 , 255 , 255 , 255 } ,
|
||||
{ 4 , 5 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 4 , 5 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 4 , 5 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 4 , 5 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 4 , 5 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 4 , 5 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 4 , 5 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 4 , 5 , 255 , 255 , 255 } ,
|
||||
{ 3 , 4 , 5 , 255 , 255 , 255 , 255 , 255 } , { 0 , 3 , 4 , 5 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 3 , 4 , 5 , 255 , 255 , 255 , 255 } , { 0 , 1 , 3 , 4 , 5 , 255 , 255 , 255 } ,
|
||||
{ 2 , 3 , 4 , 5 , 255 , 255 , 255 , 255 } , { 0 , 2 , 3 , 4 , 5 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 3 , 4 , 5 , 255 , 255 , 255 } , { 0 , 1 , 2 , 3 , 4 , 5 , 255 , 255 } ,
|
||||
{ 6 , 255 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 6 , 255 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 6 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 6 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 6 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 6 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 6 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 6 , 255 , 255 , 255 , 255 } ,
|
||||
{ 3 , 6 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 3 , 6 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 3 , 6 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 3 , 6 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 3 , 6 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 3 , 6 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 3 , 6 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 3 , 6 , 255 , 255 , 255 } ,
|
||||
{ 4 , 6 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 4 , 6 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 4 , 6 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 4 , 6 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 4 , 6 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 4 , 6 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 4 , 6 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 4 , 6 , 255 , 255 , 255 } ,
|
||||
{ 3 , 4 , 6 , 255 , 255 , 255 , 255 , 255 } , { 0 , 3 , 4 , 6 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 3 , 4 , 6 , 255 , 255 , 255 , 255 } , { 0 , 1 , 3 , 4 , 6 , 255 , 255 , 255 } ,
|
||||
{ 2 , 3 , 4 , 6 , 255 , 255 , 255 , 255 } , { 0 , 2 , 3 , 4 , 6 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 3 , 4 , 6 , 255 , 255 , 255 } , { 0 , 1 , 2 , 3 , 4 , 6 , 255 , 255 } ,
|
||||
{ 5 , 6 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 5 , 6 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 5 , 6 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 5 , 6 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 5 , 6 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 5 , 6 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 5 , 6 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 5 , 6 , 255 , 255 , 255 } ,
|
||||
{ 3 , 5 , 6 , 255 , 255 , 255 , 255 , 255 } , { 0 , 3 , 5 , 6 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 3 , 5 , 6 , 255 , 255 , 255 , 255 } , { 0 , 1 , 3 , 5 , 6 , 255 , 255 , 255 } ,
|
||||
{ 2 , 3 , 5 , 6 , 255 , 255 , 255 , 255 } , { 0 , 2 , 3 , 5 , 6 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 3 , 5 , 6 , 255 , 255 , 255 } , { 0 , 1 , 2 , 3 , 5 , 6 , 255 , 255 } ,
|
||||
{ 4 , 5 , 6 , 255 , 255 , 255 , 255 , 255 } , { 0 , 4 , 5 , 6 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 4 , 5 , 6 , 255 , 255 , 255 , 255 } , { 0 , 1 , 4 , 5 , 6 , 255 , 255 , 255 } ,
|
||||
{ 2 , 4 , 5 , 6 , 255 , 255 , 255 , 255 } , { 0 , 2 , 4 , 5 , 6 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 4 , 5 , 6 , 255 , 255 , 255 } , { 0 , 1 , 2 , 4 , 5 , 6 , 255 , 255 } ,
|
||||
{ 3 , 4 , 5 , 6 , 255 , 255 , 255 , 255 } , { 0 , 3 , 4 , 5 , 6 , 255 , 255 , 255 } ,
|
||||
{ 1 , 3 , 4 , 5 , 6 , 255 , 255 , 255 } , { 0 , 1 , 3 , 4 , 5 , 6 , 255 , 255 } ,
|
||||
{ 2 , 3 , 4 , 5 , 6 , 255 , 255 , 255 } , { 0 , 2 , 3 , 4 , 5 , 6 , 255 , 255 } ,
|
||||
{ 1 , 2 , 3 , 4 , 5 , 6 , 255 , 255 } , { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 255 } ,
|
||||
{ 7 , 255 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 7 , 255 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 7 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 7 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 7 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 7 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 7 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 7 , 255 , 255 , 255 , 255 } ,
|
||||
{ 3 , 7 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 3 , 7 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 3 , 7 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 3 , 7 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 3 , 7 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 3 , 7 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 3 , 7 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 3 , 7 , 255 , 255 , 255 } ,
|
||||
{ 4 , 7 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 4 , 7 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 4 , 7 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 4 , 7 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 4 , 7 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 4 , 7 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 4 , 7 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 4 , 7 , 255 , 255 , 255 } ,
|
||||
{ 3 , 4 , 7 , 255 , 255 , 255 , 255 , 255 } , { 0 , 3 , 4 , 7 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 3 , 4 , 7 , 255 , 255 , 255 , 255 } , { 0 , 1 , 3 , 4 , 7 , 255 , 255 , 255 } ,
|
||||
{ 2 , 3 , 4 , 7 , 255 , 255 , 255 , 255 } , { 0 , 2 , 3 , 4 , 7 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 3 , 4 , 7 , 255 , 255 , 255 } , { 0 , 1 , 2 , 3 , 4 , 7 , 255 , 255 } ,
|
||||
{ 5 , 7 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 5 , 7 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 5 , 7 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 5 , 7 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 5 , 7 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 5 , 7 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 5 , 7 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 5 , 7 , 255 , 255 , 255 } ,
|
||||
{ 3 , 5 , 7 , 255 , 255 , 255 , 255 , 255 } , { 0 , 3 , 5 , 7 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 3 , 5 , 7 , 255 , 255 , 255 , 255 } , { 0 , 1 , 3 , 5 , 7 , 255 , 255 , 255 } ,
|
||||
{ 2 , 3 , 5 , 7 , 255 , 255 , 255 , 255 } , { 0 , 2 , 3 , 5 , 7 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 3 , 5 , 7 , 255 , 255 , 255 } , { 0 , 1 , 2 , 3 , 5 , 7 , 255 , 255 } ,
|
||||
{ 4 , 5 , 7 , 255 , 255 , 255 , 255 , 255 } , { 0 , 4 , 5 , 7 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 4 , 5 , 7 , 255 , 255 , 255 , 255 } , { 0 , 1 , 4 , 5 , 7 , 255 , 255 , 255 } ,
|
||||
{ 2 , 4 , 5 , 7 , 255 , 255 , 255 , 255 } , { 0 , 2 , 4 , 5 , 7 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 4 , 5 , 7 , 255 , 255 , 255 } , { 0 , 1 , 2 , 4 , 5 , 7 , 255 , 255 } ,
|
||||
{ 3 , 4 , 5 , 7 , 255 , 255 , 255 , 255 } , { 0 , 3 , 4 , 5 , 7 , 255 , 255 , 255 } ,
|
||||
{ 1 , 3 , 4 , 5 , 7 , 255 , 255 , 255 } , { 0 , 1 , 3 , 4 , 5 , 7 , 255 , 255 } ,
|
||||
{ 2 , 3 , 4 , 5 , 7 , 255 , 255 , 255 } , { 0 , 2 , 3 , 4 , 5 , 7 , 255 , 255 } ,
|
||||
{ 1 , 2 , 3 , 4 , 5 , 7 , 255 , 255 } , { 0 , 1 , 2 , 3 , 4 , 5 , 7 , 255 } ,
|
||||
{ 6 , 7 , 255 , 255 , 255 , 255 , 255 , 255 } , { 0 , 6 , 7 , 255 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 6 , 7 , 255 , 255 , 255 , 255 , 255 } , { 0 , 1 , 6 , 7 , 255 , 255 , 255 , 255 } ,
|
||||
{ 2 , 6 , 7 , 255 , 255 , 255 , 255 , 255 } , { 0 , 2 , 6 , 7 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 6 , 7 , 255 , 255 , 255 , 255 } , { 0 , 1 , 2 , 6 , 7 , 255 , 255 , 255 } ,
|
||||
{ 3 , 6 , 7 , 255 , 255 , 255 , 255 , 255 } , { 0 , 3 , 6 , 7 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 3 , 6 , 7 , 255 , 255 , 255 , 255 } , { 0 , 1 , 3 , 6 , 7 , 255 , 255 , 255 } ,
|
||||
{ 2 , 3 , 6 , 7 , 255 , 255 , 255 , 255 } , { 0 , 2 , 3 , 6 , 7 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 3 , 6 , 7 , 255 , 255 , 255 } , { 0 , 1 , 2 , 3 , 6 , 7 , 255 , 255 } ,
|
||||
{ 4 , 6 , 7 , 255 , 255 , 255 , 255 , 255 } , { 0 , 4 , 6 , 7 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 4 , 6 , 7 , 255 , 255 , 255 , 255 } , { 0 , 1 , 4 , 6 , 7 , 255 , 255 , 255 } ,
|
||||
{ 2 , 4 , 6 , 7 , 255 , 255 , 255 , 255 } , { 0 , 2 , 4 , 6 , 7 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 4 , 6 , 7 , 255 , 255 , 255 } , { 0 , 1 , 2 , 4 , 6 , 7 , 255 , 255 } ,
|
||||
{ 3 , 4 , 6 , 7 , 255 , 255 , 255 , 255 } , { 0 , 3 , 4 , 6 , 7 , 255 , 255 , 255 } ,
|
||||
{ 1 , 3 , 4 , 6 , 7 , 255 , 255 , 255 } , { 0 , 1 , 3 , 4 , 6 , 7 , 255 , 255 } ,
|
||||
{ 2 , 3 , 4 , 6 , 7 , 255 , 255 , 255 } , { 0 , 2 , 3 , 4 , 6 , 7 , 255 , 255 } ,
|
||||
{ 1 , 2 , 3 , 4 , 6 , 7 , 255 , 255 } , { 0 , 1 , 2 , 3 , 4 , 6 , 7 , 255 } ,
|
||||
{ 5 , 6 , 7 , 255 , 255 , 255 , 255 , 255 } , { 0 , 5 , 6 , 7 , 255 , 255 , 255 , 255 } ,
|
||||
{ 1 , 5 , 6 , 7 , 255 , 255 , 255 , 255 } , { 0 , 1 , 5 , 6 , 7 , 255 , 255 , 255 } ,
|
||||
{ 2 , 5 , 6 , 7 , 255 , 255 , 255 , 255 } , { 0 , 2 , 5 , 6 , 7 , 255 , 255 , 255 } ,
|
||||
{ 1 , 2 , 5 , 6 , 7 , 255 , 255 , 255 } , { 0 , 1 , 2 , 5 , 6 , 7 , 255 , 255 } ,
|
||||
{ 3 , 5 , 6 , 7 , 255 , 255 , 255 , 255 } , { 0 , 3 , 5 , 6 , 7 , 255 , 255 , 255 } ,
|
||||
{ 1 , 3 , 5 , 6 , 7 , 255 , 255 , 255 } , { 0 , 1 , 3 , 5 , 6 , 7 , 255 , 255 } ,
|
||||
{ 2 , 3 , 5 , 6 , 7 , 255 , 255 , 255 } , { 0 , 2 , 3 , 5 , 6 , 7 , 255 , 255 } ,
|
||||
{ 1 , 2 , 3 , 5 , 6 , 7 , 255 , 255 } , { 0 , 1 , 2 , 3 , 5 , 6 , 7 , 255 } ,
|
||||
{ 4 , 5 , 6 , 7 , 255 , 255 , 255 , 255 } , { 0 , 4 , 5 , 6 , 7 , 255 , 255 , 255 } ,
|
||||
{ 1 , 4 , 5 , 6 , 7 , 255 , 255 , 255 } , { 0 , 1 , 4 , 5 , 6 , 7 , 255 , 255 } ,
|
||||
{ 2 , 4 , 5 , 6 , 7 , 255 , 255 , 255 } , { 0 , 2 , 4 , 5 , 6 , 7 , 255 , 255 } ,
|
||||
{ 1 , 2 , 4 , 5 , 6 , 7 , 255 , 255 } , { 0 , 1 , 2 , 4 , 5 , 6 , 7 , 255 } ,
|
||||
{ 3 , 4 , 5 , 6 , 7 , 255 , 255 , 255 } , { 0 , 3 , 4 , 5 , 6 , 7 , 255 , 255 } ,
|
||||
{ 1 , 3 , 4 , 5 , 6 , 7 , 255 , 255 } , { 0 , 1 , 3 , 4 , 5 , 6 , 7 , 255 } ,
|
||||
{ 2 , 3 , 4 , 5 , 6 , 7 , 255 , 255 } , { 0 , 2 , 3 , 4 , 5 , 6 , 7 , 255 } ,
|
||||
{ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 255 } , { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 } };
|
||||
|
||||
#endif
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
noinst_PROGRAMS = graph_tests packed_mphf_tests mphf_tests
|
||||
noinst_PROGRAMS = graph_tests packed_mphf_tests mphf_tests select_tests
|
||||
|
||||
INCLUDES = -I../src/
|
||||
|
||||
|
|
@ -10,3 +10,6 @@ packed_mphf_tests_LDADD = ../src/libcmph.la
|
|||
|
||||
mphf_tests_SOURCES = mphf_tests.c
|
||||
mphf_tests_LDADD = ../src/libcmph.la
|
||||
|
||||
select_tests_SOURCES = select_tests.c
|
||||
select_tests_LDADD = ../src/libcmph.la
|
||||
|
|
|
|||
|
|
@ -0,0 +1,96 @@
|
|||
#include "../src/select.h"
|
||||
|
||||
#define DEBUG
|
||||
#include "../src/debug.h"
|
||||
#include <stdlib.h>
|
||||
|
||||
static inline void print_values(select_t * sel)
|
||||
{
|
||||
register cmph_uint32 index;
|
||||
|
||||
index = select_query(sel, 0);
|
||||
fprintf(stderr, "Index[0]\t= %u\n", index - 0);
|
||||
|
||||
index = select_next_query(sel, index);
|
||||
fprintf(stderr, "Next Index\t= %u\n", index);
|
||||
|
||||
index = select_query(sel, 1);
|
||||
fprintf(stderr, "Index[1]\t= %u\n", index - 1);
|
||||
|
||||
index = select_next_query(sel, index);
|
||||
fprintf(stderr, "Next Index\t= %u\n", index);
|
||||
|
||||
index = select_query(sel, 2);
|
||||
fprintf(stderr, "Index[2]\t= %u\n", index - 2);
|
||||
|
||||
index = select_next_query(sel, index);
|
||||
fprintf(stderr, "Next Index\t= %u\n", index);
|
||||
|
||||
index = select_query(sel, 3);
|
||||
fprintf(stderr, "Index[3]\t= %u\n", index - 3);
|
||||
}
|
||||
|
||||
|
||||
static inline void print_values_packed(char * sel_packed)
|
||||
{
|
||||
register cmph_uint32 index;
|
||||
|
||||
index = select_query_packed(sel_packed, 0);
|
||||
fprintf(stderr, "Index[0]\t= %u\n", index - 0);
|
||||
|
||||
index = select_next_query_packed(sel_packed, index);
|
||||
fprintf(stderr, "Next Index\t= %u\n", index);
|
||||
|
||||
index = select_query_packed(sel_packed, 1);
|
||||
fprintf(stderr, "Index[1]\t= %u\n", index - 1);
|
||||
|
||||
index = select_next_query_packed(sel_packed, index);
|
||||
fprintf(stderr, "Next Index\t= %u\n", index);
|
||||
|
||||
index = select_query_packed(sel_packed, 2);
|
||||
fprintf(stderr, "Index[2]\t= %u\n", index - 2);
|
||||
|
||||
index = select_next_query_packed(sel_packed, index);
|
||||
fprintf(stderr, "Next Index\t= %u\n", index);
|
||||
|
||||
index = select_query_packed(sel_packed, 3);
|
||||
fprintf(stderr, "Index[3]\t= %u\n", index - 3);
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
select_t sel;
|
||||
cmph_uint32 n = 4;
|
||||
cmph_uint32 keys_vec[4] = {0,1,2,3};
|
||||
cmph_uint32 m = keys_vec[3];
|
||||
char *buf = NULL;
|
||||
cmph_uint32 buflen = 0;
|
||||
char * select_packed = NULL;
|
||||
cmph_uint32 select_pack_size = 0;
|
||||
|
||||
select_init(&sel, n, m);
|
||||
select_generate(&sel, keys_vec);
|
||||
fprintf(stderr, "Space usage = %f\n", select_get_space_usage(&sel));
|
||||
print_values(&sel);
|
||||
|
||||
fprintf(stderr, "Dumping select structure\n");
|
||||
select_dump(&sel, &buf, &buflen);
|
||||
|
||||
select_destroy(&sel);
|
||||
fprintf(stderr, "Loading select structure\n");
|
||||
|
||||
select_load(&sel, buf, buflen);
|
||||
print_values(&sel);
|
||||
free(buf);;
|
||||
|
||||
select_pack_size = select_packed_size(&sel);
|
||||
|
||||
select_packed = (char *) calloc(select_pack_size, sizeof(char));
|
||||
select_pack(&sel, select_packed);
|
||||
|
||||
fprintf(stderr, "Querying the packed select structure\n");
|
||||
print_values_packed(select_packed);
|
||||
|
||||
free(select_packed);
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue