select data structure added

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\
+libcmph_la_SOURCES =  hash.c jenkins_hash.c\
-				  bitbool.h\
+		      vstack.c vqueue.c\
-				  cmph_types.h\
+		      graph.c cmph.c  cmph_structs.c\
-				  hash.h hash_state.h hash.c\
+		      chm.c bmz.c bmz8.c bdz.c bdz_ph.c\
-				  jenkins_hash.h jenkins_hash.c\
+		      buffer_manager.c buffer_entry.c\
-				  vstack.h vstack.c\
+		      brz.c fch.c fch_buckets.c \
-				  vqueue.h vqueue.c\
+		      select.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_LDFLAGS = -version-info 0:0:0
 

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);
+	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(buf, (size_t)buflen, (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);
+	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
+	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(&(data->r), 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);
+	nbytes = fwrite(&(data->k), sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(&(data->b), sizeof(cmph_uint8), (size_t)1, fd);
+	nbytes = fwrite(&(data->b), sizeof(cmph_uint8), (size_t)1, fd);
-	fwrite(&(data->ranktablesize), sizeof(cmph_uint32), (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);	
+	nbytes = fread(&(bdz->n), sizeof(cmph_uint32), (size_t)1, f);	
-	fread(&(bdz->m), sizeof(cmph_uint32), (size_t)1, f);	
+	nbytes = fread(&(bdz->m), sizeof(cmph_uint32), (size_t)1, f);	
-	fread(&(bdz->r), 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);
+	nbytes = fread(&(bdz->k), sizeof(cmph_uint32), (size_t)1, f);
-	fread(&(bdz->b), sizeof(cmph_uint8), (size_t)1, f);
+	nbytes = fread(&(bdz->b), sizeof(cmph_uint8), (size_t)1, f);
-	fread(&(bdz->ranktablesize), sizeof(cmph_uint32), (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;

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);
+	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(buf, (size_t)buflen, (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);
+	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
+	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(&(data->r), 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);	
+	nbytes = fread(&(bdz_ph->n), sizeof(cmph_uint32), (size_t)1, f);	
-	fread(&(bdz_ph->m), sizeof(cmph_uint32), (size_t)1, f);	
+	nbytes = 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->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;

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);
+	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(buf, (size_t)buflen, (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);
+	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(buf, (size_t)buflen, (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);
+	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(&(data->m), 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);	
+	nbytes = fread(&(bmz->n), sizeof(cmph_uint32), (size_t)1, f);	
-	fread(&(bmz->m), 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]);

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);
+	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(buf, (size_t)buflen, (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);
+	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(buf, (size_t)buflen, (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);
+	nbytes = fwrite(&(data->n), sizeof(cmph_uint8), (size_t)1, fd);
-	fwrite(&(data->m), 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);	
+	nbytes = fread(&(bmz8->n), sizeof(cmph_uint8), (size_t)1, f);	
-	fread(&(bmz8->m), 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]);

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);
+	nbytes = 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);
+	nbytes = fwrite(&(brz->m), sizeof(brz->m), (size_t)1, brz->mphf_fd);
-	fwrite(&(brz->c), sizeof(double), (size_t)1, brz->mphf_fd);
+	nbytes = fwrite(&(brz->c), sizeof(double), (size_t)1, brz->mphf_fd);
-	fwrite(&(brz->algo), sizeof(brz->algo), (size_t)1, brz->mphf_fd);
+	nbytes = 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
+	nbytes = 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(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);
+        nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
-        fwrite(buf, (size_t)buflen, (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);	
+	nbytes = 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->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);
+	nbytes = fread(&(brz->c), sizeof(double), (size_t)1, f);
-	fread(&(brz->algo), sizeof(brz->algo), (size_t)1, f); // Reading algo.
+	nbytes = 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->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;
 }
 

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);
+	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(buf, (size_t)buflen, (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);
+	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(buf, (size_t)buflen, (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);
+	nbytes = fwrite(&(data->n), sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(&(data->m), 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);	
+	nbytes = fread(&(chm->n), sizeof(cmph_uint32), (size_t)1, f);	
-	fread(&(chm->m), 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]);

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;

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);
+	register cmph_uint32 nbytes;
-	fwrite(&(mphf->size), sizeof(mphf->size), (size_t)1, fd);
+	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);
 

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__)

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);
+	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(buf, (size_t)buflen, (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);
+	nbytes = fwrite(&buflen, sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(buf, (size_t)buflen, (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);
+	nbytes = fwrite(&(data->m), sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(&(data->c), sizeof(double), (size_t)1, fd);
+	nbytes = fwrite(&(data->c), sizeof(double), (size_t)1, fd);
-	fwrite(&(data->b), sizeof(cmph_uint32), (size_t)1, fd);
+	nbytes = fwrite(&(data->b), sizeof(cmph_uint32), (size_t)1, fd);
-	fwrite(&(data->p1), sizeof(double), (size_t)1, fd);
+	nbytes = fwrite(&(data->p1), sizeof(double), (size_t)1, fd);
-	fwrite(&(data->p2), sizeof(double), (size_t)1, fd);
+	nbytes = fwrite(&(data->p2), sizeof(double), (size_t)1, fd);
-	fwrite(data->g, sizeof(cmph_uint32)*(data->b), (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);
+	nbytes = fread(&(fch->m), sizeof(cmph_uint32), (size_t)1, f);
-	fread(&(fch->c), sizeof(double), (size_t)1, f);
+	nbytes = fread(&(fch->c), sizeof(double), (size_t)1, f);
-	fread(&(fch->b), sizeof(cmph_uint32), (size_t)1, f);
+	nbytes = fread(&(fch->b), sizeof(cmph_uint32), (size_t)1, f);
-	fread(&(fch->p1), sizeof(double), (size_t)1, f);
+	nbytes = fread(&(fch->p1), sizeof(double), (size_t)1, f);
-	fread(&(fch->p2), 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: ");

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;

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
  */ 

src/select.c

@@ -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);
+}

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

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

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

tests/select_tests.c

@@ -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;
+}