From 7eb145226c5092fad4a5c549f6cb9b7e8d7c21cf Mon Sep 17 00:00:00 2001 From: fc_botelho Date: Sat, 14 Mar 2009 23:24:05 +0000 Subject: [PATCH] select data structure added --- src/Makefile | 36 ++-- src/Makefile.am | 27 +-- src/Makefile.in | 30 +--- src/bdz.c | 42 ++--- src/bdz_ph.c | 26 +-- src/bmz.c | 31 ++-- src/bmz8.c | 30 ++-- src/brz.c | 55 ++++--- src/chm.c | 32 ++-- src/cmph.c | 3 +- src/cmph_structs.c | 10 +- src/cmph_types.h | 5 + src/fch.c | 43 ++--- src/graph.c | 2 +- src/jenkins_hash.h | 2 +- src/select.c | 327 +++++++++++++++++++++++++++++++++++++ src/select.h | 61 +++++++ src/select_lookup_tables.h | 170 +++++++++++++++++++ tests/Makefile.am | 5 +- tests/select_tests.c | 96 +++++++++++ 20 files changed, 838 insertions(+), 195 deletions(-) create mode 100644 src/select.c create mode 100644 src/select.h create mode 100644 src/select_lookup_tables.h create mode 100644 tests/select_tests.c diff --git a/src/Makefile b/src/Makefile index 4da7130..10149dc 100644 --- a/src/Makefile +++ b/src/Makefile @@ -60,7 +60,7 @@ libcmph_la_LIBADD = am_libcmph_la_OBJECTS = hash.lo jenkins_hash.lo vstack.lo vqueue.lo \ graph.lo cmph.lo cmph_structs.lo chm.lo bmz.lo bmz8.lo bdz.lo \ bdz_ph.lo buffer_manager.lo buffer_entry.lo brz.lo fch.lo \ - fch_buckets.lo + fch_buckets.lo select.lo libcmph_la_OBJECTS = $(am_libcmph_la_OBJECTS) libcmph_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ @@ -98,7 +98,7 @@ AUTOMAKE = ${SHELL} /home/fbotelho/papers/conferences/djamel/cmph/missing --run AWK = gawk CC = gcc CCDEPMODE = depmode=gcc3 -CFLAGS = -O3 +CFLAGS = -O3 -Wall -Werror -lm CPP = gcc -E CPPFLAGS = CYGPATH_W = echo @@ -120,8 +120,8 @@ INSTALL_PROGRAM = ${INSTALL} INSTALL_SCRIPT = ${INSTALL} INSTALL_STRIP_PROGRAM = $(install_sh) -c -s LD = /usr/bin/ld -m elf_x86_64 -LDFLAGS = -lm -LIBM = -lm +LDFLAGS = +LIBM = LIBOBJS = LIBS = LIBTOOL = $(SHELL) $(top_builddir)/libtool @@ -201,26 +201,13 @@ top_builddir = .. top_srcdir = .. 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 cmph_SOURCES = main.c wingetopt.h wingetopt.c @@ -341,6 +328,7 @@ include ./$(DEPDIR)/graph.Plo include ./$(DEPDIR)/hash.Plo include ./$(DEPDIR)/jenkins_hash.Plo include ./$(DEPDIR)/main.Po +include ./$(DEPDIR)/select.Plo include ./$(DEPDIR)/vqueue.Plo include ./$(DEPDIR)/vstack.Plo include ./$(DEPDIR)/wingetopt.Po diff --git a/src/Makefile.am b/src/Makefile.am index 892be35..acd2796 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -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 diff --git a/src/Makefile.in b/src/Makefile.in index f64ed0a..08994a6 100644 --- a/src/Makefile.in +++ b/src/Makefile.in @@ -60,7 +60,7 @@ libcmph_la_LIBADD = am_libcmph_la_OBJECTS = hash.lo jenkins_hash.lo vstack.lo vqueue.lo \ graph.lo cmph.lo cmph_structs.lo chm.lo bmz.lo bmz8.lo bdz.lo \ bdz_ph.lo buffer_manager.lo buffer_entry.lo brz.lo fch.lo \ - fch_buckets.lo + fch_buckets.lo select.lo libcmph_la_OBJECTS = $(am_libcmph_la_OBJECTS) libcmph_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ @@ -201,26 +201,13 @@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ 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 cmph_SOURCES = main.c wingetopt.h wingetopt.c @@ -341,6 +328,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hash.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jenkins_hash.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/select.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vqueue.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vstack.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/wingetopt.Po@am__quote@ diff --git a/src/bdz.c b/src/bdz.c index 280731e..03c9dcc 100755 --- a/src/bdz.c +++ b/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; diff --git a/src/bdz_ph.c b/src/bdz_ph.c index cf1f76b..2c91086 100755 --- a/src/bdz_ph.c +++ b/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; diff --git a/src/bmz.c b/src/bmz.c index 71f9fd6..2d71e7a 100644 --- a/src/bmz.c +++ b/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]); diff --git a/src/bmz8.c b/src/bmz8.c index efc816c..02117b2 100644 --- a/src/bmz8.c +++ b/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]); diff --git a/src/brz.c b/src/brz.c index 65ce051..e34d7f6 100755 --- a/src/brz.c +++ b/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; } diff --git a/src/chm.c b/src/chm.c index daf0ae7..5669080 100644 --- a/src/chm.c +++ b/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]); diff --git a/src/cmph.c b/src/cmph.c index 77b3262..5142daf 100644 --- a/src/cmph.c +++ b/src/cmph.c @@ -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; diff --git a/src/cmph_structs.c b/src/cmph_structs.c index ae63941..fd4040d 100644 --- a/src/cmph_structs.c +++ b/src/cmph_structs.c @@ -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); diff --git a/src/cmph_types.h b/src/cmph_types.h index b2d848a..ef45c24 100644 --- a/src/cmph_types.h +++ b/src/cmph_types.h @@ -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__) diff --git a/src/fch.c b/src/fch.c index f823c09..b634896 100644 --- a/src/fch.c +++ b/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: "); diff --git a/src/graph.c b/src/graph.c index bb65877..e084be8 100644 --- a/src/graph.c +++ b/src/graph.c @@ -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; diff --git a/src/jenkins_hash.h b/src/jenkins_hash.h index fb422d4..8e8b917 100644 --- a/src/jenkins_hash.h +++ b/src/jenkins_hash.h @@ -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 */ diff --git a/src/select.c b/src/select.c new file mode 100644 index 0000000..b3a7c29 --- /dev/null +++ b/src/select.c @@ -0,0 +1,327 @@ +#include +#include +#include +#include +#include +#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); +} diff --git a/src/select.h b/src/select.h new file mode 100644 index 0000000..bf2380b --- /dev/null +++ b/src/select.h @@ -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 diff --git a/src/select_lookup_tables.h b/src/select_lookup_tables.h new file mode 100644 index 0000000..efd595e --- /dev/null +++ b/src/select_lookup_tables.h @@ -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 diff --git a/tests/Makefile.am b/tests/Makefile.am index d0235d2..f0688a9 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -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 diff --git a/tests/select_tests.c b/tests/select_tests.c new file mode 100644 index 0000000..8edc30f --- /dev/null +++ b/tests/select_tests.c @@ -0,0 +1,96 @@ +#include "../src/select.h" + +#define DEBUG +#include "../src/debug.h" +#include + +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; +}