socsvn commit: r236881 - soc2012/gpf/misc

gpf at FreeBSD.org gpf at FreeBSD.org
Fri Jun 1 16:30:00 UTC 2012


Author: gpf
Date: Fri Jun  1 16:29:59 2012
New Revision: 236881
URL: http://svnweb.FreeBSD.org/socsvn/?view=rev&rev=236881

Log:
  new version of test_checksum.c for the new version of .pefs.checksum that is created
  with cuckoo hashing.
  

Modified:
  soc2012/gpf/misc/test_checksum.c

Modified: soc2012/gpf/misc/test_checksum.c
==============================================================================
--- soc2012/gpf/misc/test_checksum.c	Fri Jun  1 15:52:41 2012	(r236880)
+++ soc2012/gpf/misc/test_checksum.c	Fri Jun  1 16:29:59 2012	(r236881)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  */
- 
+
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
@@ -84,57 +84,40 @@
 };
 
 struct bucket {
-	struct file_header_head file_headers;
-	uint32_t offset_to_chain;
-	uint32_t nelements;
-	uint32_t elements_loaded;
+	struct file_header *fhp;
 };
 
-struct hash_table {
-	struct bucket *buckets;
-	uint32_t size; /* how many buckets */
+struct cuckoo_hash_table {
+	struct bucket *buckets1;
+	struct bucket *buckets2;
+	uint32_t size; /* how many buckets in each table */
 	uint32_t nelements;
 };
 
-
 static int
-pefs_allocate_hash_table(struct hash_table *checksum_hash_tablep, uint32_t size)
+pefs_allocate_hash_table(struct cuckoo_hash_table *chtp, uint32_t size)
 {
 	uint32_t i;
 
-	checksum_hash_tablep->size = size;
-	checksum_hash_tablep->buckets = malloc (size * sizeof(struct bucket));
-
-	if (checksum_hash_tablep->buckets == NULL) {
+	chtp->size = size;
+	chtp->buckets1 = malloc (size * sizeof(struct bucket));
+	if (chtp->buckets1 == NULL) {
 		perror("memory allocation error");
 		return (ERROR);
 	}
 
-	for (i = 0; i < checksum_hash_tablep->size; i++) {
-		checksum_hash_tablep->buckets[i].nelements = 0;
-		checksum_hash_tablep->buckets[i].elements_loaded = 0;
-		LIST_INIT(&(checksum_hash_tablep->buckets[i].file_headers));
+	chtp->buckets2 = malloc (size * sizeof(struct bucket));
+	if (chtp->buckets2 == NULL) {
+		perror("memory allocation error");
+		return (ERROR);
 	}
 
-	return (0);
-}
-
-static void
-pefs_add_to_bucket(struct bucket *bucketp, struct file_header *fhp)
-{
-	struct file_header *elementp;
-	struct file_header *last;
-
-	if (bucketp->elements_loaded == 0)
-		LIST_INSERT_HEAD(&(bucketp->file_headers), fhp, bucket_entries);
-	else {
-		LIST_FOREACH(elementp, &(bucketp->file_headers), bucket_entries) {
-			last = elementp;
-		}
-		LIST_INSERT_AFTER(last, fhp, bucket_entries);
+	for (i = 0; i < chtp->size; i++) {
+		chtp->buckets1[i].fhp = NULL;
+		chtp->buckets2[i].fhp = NULL;
 	}
 
-	bucketp->elements_loaded++;
+	return (0);
 }
 
 static void
@@ -143,24 +126,41 @@
 	TAILQ_INSERT_TAIL(&(fhp->checksums), csp, checksum_entries);
 }
 
-/* for debugging purposes */
 static void
-pefs_print_hash_table(struct hash_table *checksum_hash_tablep, uint8_t hash_len)
+pefs_print_hash_table(struct cuckoo_hash_table *chtp, uint8_t hash_len)
 {
 	struct file_header *fhp;
 	struct checksum *csp;
 	uint32_t i,j;
 
-	printf("\n+++Printing Hash Table+++\n\n");
-	for (i = 0; i < checksum_hash_tablep->size; i++) {
-		printf("\nbucket %d with elements: %u\n", i, checksum_hash_tablep->buckets[i].nelements);
-		LIST_FOREACH(fhp, &(checksum_hash_tablep->buckets[i].file_headers), bucket_entries) {
-			printf("\tid = %llu!\tnhashes = %d\n", fhp->file_id, fhp->nhashes);
+	dprintf(("\n+++Printing Hash Table 1+++\n\n"));
+	for (i = 0; i < chtp->size; i++) {
+		fhp = chtp->buckets1[i].fhp;
+		dprintf(("\nbucket %d with element: %d\n", i, fhp == NULL ? 0 : 1));
+		if (fhp != NULL) {
+			//dprintf(("\tpath=%s\tid = %llu\tnhashes = %d\n", fhp->path, fhp->file_id, fhp->nhashes));
+			dprintf(("\tid = %llu\tnhashes = %d\n", fhp->file_id, fhp->nhashes));
+			TAILQ_FOREACH(csp, &(fhp->checksums), checksum_entries) {
+				dprintf(("\t\tdigest="));
+				for (j = 0; j < hash_len; j++)
+					dprintf(("%02x", csp->hash[j]));
+				dprintf(("\n"));
+			}
+		}
+	}
+
+	dprintf(("\n+++Printing Hash Table 2+++\n\n"));
+	for (i = 0; i < chtp->size; i++) {
+		fhp = chtp->buckets2[i].fhp;
+		dprintf(("\nbucket %d with element: %d\n", i, fhp == NULL ? 0 : 1));
+		if (fhp != NULL) {
+			//dprintf(("\tpath=%s\tid = %llu\tnhashes = %d\n", fhp->path, fhp->file_id, fhp->nhashes));
+			dprintf(("\tid = %llu\tnhashes = %d\n", fhp->file_id, fhp->nhashes));
 			TAILQ_FOREACH(csp, &(fhp->checksums), checksum_entries) {
-				printf("\t\tdigest=");
+				dprintf(("\t\tdigest="));
 				for (j = 0; j < hash_len; j++)
-					printf("%02x", csp->hash[j]);
-				printf("\n");
+					dprintf(("%02x", csp->hash[j]));
+				dprintf(("\n"));
 			}
 		}
 	}
@@ -216,70 +216,68 @@
 }
 
 static int
-pefs_read_bucket(int fdin, struct bucket *bp, uint32_t *buckets_offset)
-{
-	uint32_t offset_to_chain, nelements;
-	int bytes;
-
-	//dprintf(("bucket offset = %d\n", *buckets_offset));
-
-	bytes = pread(fdin, &offset_to_chain, sizeof(offset_to_chain), *buckets_offset);
-	if (bytes != sizeof(offset_to_chain)) {
-		perror("error reading from .pefs.checksum");
-		return (ERROR);
-	}
-	bp->offset_to_chain = le32toh(offset_to_chain);
-	(*buckets_offset)+= sizeof(offset_to_chain);
-
-	bytes = pread(fdin, &nelements, sizeof(nelements), *buckets_offset);
-	if (bytes != sizeof(nelements)) {
-		perror("error reading from .pefs.checksum");
-		return (ERROR);
-	}
-	bp->nelements = le32toh(nelements);
-	(*buckets_offset)+= sizeof(nelements);
-
-	//dprintf(("\n++priting bucket info++\n"));
-	//dprintf(("offset to chain %d\nnelements %d\n", bp->offset_to_chain, bp->nelements));
-
-	return (0);
-}
-
-static int
-pefs_read_file_header(int fdin, struct file_header *fhp, uint32_t *fh_offset)
+pefs_read_file_header(int fdin, struct file_header *fhp, uint32_t *buckets_offset)
 {
 	uint64_t file_id;
 	uint32_t nhashes, offset_to_checksums;
 	int bytes;
 
-	bytes = pread(fdin, &nhashes, sizeof(nhashes), *fh_offset);
+	bytes = pread(fdin, &nhashes, sizeof(nhashes), *buckets_offset);
 	if (bytes != sizeof(nhashes)) {
 		perror("error reading from .pefs.checksum");
 		return (ERROR);
 	}
 	fhp->nhashes = le32toh(nhashes);
-	(*fh_offset)+= sizeof(nhashes);
+	(*buckets_offset)+= sizeof(nhashes);
 
-	bytes = pread(fdin, &offset_to_checksums, sizeof(offset_to_checksums), *fh_offset);
+	bytes = pread(fdin, &offset_to_checksums, sizeof(offset_to_checksums), *buckets_offset);
 	if (bytes != sizeof(offset_to_checksums)) {
 		perror("error reading from .pefs.checksum");
 		return (ERROR);
 	}
 	fhp->offset_to_checksums = le32toh(offset_to_checksums);
-	(*fh_offset)+= sizeof(offset_to_checksums);
-	
-	bytes = pread(fdin, &file_id, sizeof(file_id), *fh_offset);
+	(*buckets_offset)+= sizeof(offset_to_checksums);
+
+	bytes = pread(fdin, &file_id, sizeof(file_id), *buckets_offset);
 	if (bytes != sizeof(file_id)) {
 		perror("error reading from .pefs.checksum");
 		return (ERROR);
 	}
 	fhp->file_id = le64toh(file_id);
-	(*fh_offset)+= sizeof(file_id);
-	
+	(*buckets_offset)+= sizeof(file_id);
+
 	//dprintf(("\nfile header offset = %d\n", *fh_offset));
 	//dprintf(("\n++priting file header info++\n"));
-	//dprintf(("nhashes %d\noffset_to_checksums %d\n", fhp->nhashes, fhp->offset_to_checksums));
-	//dprintf(("file id %d\n", (int)fhp->file_id));
+	//dprintf(("nhashes %d\noffset_to_checksums %u\n", fhp->nhashes, fhp->offset_to_checksums));
+	//dprintf(("file id %llu\n", fhp->file_id));
+
+	return (0);
+}
+
+static int
+pefs_read_bucket(int fdin, struct bucket *bp, uint32_t *buckets_offset)
+{
+	struct file_header *fhp;
+	int error;
+
+	//dprintf(("bucket offset = %d\n", *buckets_offset));
+	fhp = malloc(sizeof(struct file_header));
+	if (fhp == NULL) {
+		perror("malloc");
+		return (ERROR);
+	}
+
+	error = pefs_read_file_header(fdin, fhp, buckets_offset);
+	if (error != 0)
+		return (error);
+
+	if (fhp->nhashes == 0) {
+		free(fhp);
+		fhp = NULL;
+	}
+	bp->fhp = fhp;
+
+	//dprintf(("\n++priting bucket info++\n"));
 
 	return (0);
 }
@@ -295,7 +293,7 @@
 		return (ERROR);
 	}
 	(*hashes_offset)+= hash_len;
-	
+
 	//dprintf(("hashes offset = %d\n", *hashes_offset));
 	//dprintf(("hash %s\n", csp->hash));
 
@@ -303,12 +301,12 @@
 }
 
 static int
-pefs_read_checksum_file(int fdin, struct checksum_file_header *cfhp, struct hash_table *chtp)
+pefs_read_checksum_file(int fdin, struct checksum_file_header *cfhp, struct cuckoo_hash_table *chtp)
 {
 	struct bucket *bp;
 	struct checksum *csp;
 	struct file_header *fhp;
-	uint32_t i, j, k, buckets_offset, fh_offset, hashes_offset;
+	uint32_t i, k, buckets_offset, hashes_offset;
 	int error;
 
 	error = pefs_read_checksum_file_header(fdin, cfhp);
@@ -323,27 +321,47 @@
 	buckets_offset = cfhp->offset_to_hash_table;
 
 	for (i = 0; i < chtp->size; i++) {
-		bp = &chtp->buckets[i];
+		bp = &chtp->buckets1[i];
 		error = pefs_read_bucket(fdin, bp, &buckets_offset);
 		if (error != 0)
 			return (error);
 
-		fh_offset = bp->offset_to_chain;
+		fhp = bp->fhp;
+		if (fhp != NULL) {
+			TAILQ_INIT(&(fhp->checksums));
+			hashes_offset = fhp->offset_to_checksums;
+
+			for (k = 0; k < fhp->nhashes; k++) {
+				csp = malloc(sizeof(struct checksum));
+				if (csp == NULL) {
+					perror("malloc");
+					return (ERROR);
+				}
+				csp->hash = malloc(cfhp->hash_len);
+				if (csp->hash == NULL) {
+					perror("malloc");
+					return (ERROR);
+				}
 
-		for (j = 0; j < bp->nelements; j++) {
-			fhp = malloc(sizeof(struct file_header));
-			if (fhp == NULL) {
-				perror("malloc");
-				return (ERROR);
+				error = pefs_read_hash(fdin, csp, &hashes_offset, cfhp->hash_len);
+				if (error != 0)
+					return (error);
+
+				pefs_add_to_file_header(fhp, csp);
 			}
+		}
+	}
 
-			error = pefs_read_file_header(fdin, fhp, &fh_offset);
-			if (error != 0)
-				return (ERROR);
+	for (i = 0; i < chtp->size; i++) {
+		bp = &chtp->buckets2[i];
+		error = pefs_read_bucket(fdin, bp, &buckets_offset);
+		if (error != 0)
+			return (error);
 
+		fhp = bp->fhp;
+		if (fhp != NULL) {
 			TAILQ_INIT(&(fhp->checksums));
 			hashes_offset = fhp->offset_to_checksums;
-			pefs_add_to_bucket(bp, fhp);
 
 			for (k = 0; k < fhp->nhashes; k++) {
 				csp = malloc(sizeof(struct checksum));
@@ -360,7 +378,7 @@
 				error = pefs_read_hash(fdin, csp, &hashes_offset, cfhp->hash_len);
 				if (error != 0)
 					return (error);
-				
+
 				pefs_add_to_file_header(fhp, csp);
 			}
 		}
@@ -377,15 +395,14 @@
 
 /*
  * XXXgpf: Purpose of code is to test validity of a .pefs.checksum file.
- * Output from this program's pefs_print_hash_table() is checked against 
+ * Output from this program's pefs_print_hash_table() is checked against
  * output from sbin/pefs' pefs_print_hash_table(). They should match.
- * 
  */
 int
 main(int argc, char *argv[])
 {
 	char checksum_path[MAXPATHLEN];
-	struct hash_table checksum_hash_table;
+	struct cuckoo_hash_table checksum_hash_table;
 	struct checksum_file_header cfh;
 	int error, fdin;
 
@@ -404,7 +421,8 @@
 	error = pefs_read_checksum_file(fdin, &cfh, &checksum_hash_table);
 
 	/* this output should be the same as the one from sbin/pefs */
-	pefs_print_hash_table(&checksum_hash_table, cfh.hash_len);
+	if (error == 0)
+		pefs_print_hash_table(&checksum_hash_table, cfh.hash_len);
 
 	close(fdin);
 


More information about the svn-soc-all mailing list