[Http-crcsync] crccache ready for some testing I think

Rusty Russell rusty at rustcorp.com.au
Tue Apr 7 00:23:18 EDT 2009


On Monday 06 April 2009 00:37:50 Alex Wulms wrote:
> All,
> 
> I have updated crccache as per below mail. Changes are in the git repository.
> 
> 
> Rusty,
> 
> I have slightly chanced crcsync for how it handles the final_size. 
> Your code was expecting: 0 < final_size <= block_size
> I have changed it into: 0 <= final_size < block_size
> 
> Reason for the change is that it makes both your code and the crccache code 
> simpler.
...
> + * @final_size: the final block size (0 <= final_size < blocksize).

I made the same change, then reverted.  Because it's not the size of the final
block, is it?  This is terribly misleading.

Fortunately, this can be fixed by simply renaming it to "tail_size".

=== modified file 'ccan/crcsync/crcsync.c'
--- ccan/crcsync/crcsync.c	2009-04-04 11:35:46 +0000
+++ ccan/crcsync/crcsync.c	2009-04-07 04:16:34 +0000
@@ -35,8 +35,8 @@
 	int have_match;
 
 	/* Final block is special (if a different size) */
-	size_t final_size;
-	uint32_t final_crc;
+	size_t tail_size;
+	uint32_t tail_crc;
 
 	/* Uncrc tab. */
 	uint32_t uncrc_tab[256];
@@ -66,25 +66,20 @@
 
 struct crc_context *crc_context_new(size_t block_size, unsigned crcbits,
 				    const uint32_t crc[], unsigned num_crcs,
-				    size_t final_size)
+				    size_t tail_size)
 {
 	struct crc_context *ctx;
 
 	assert(num_crcs > 0);
 	assert(block_size > 0);
-	assert(final_size > 0);
-	assert(final_size <= block_size);
+	assert(tail_size < block_size);
 
 	ctx = malloc(sizeof(*ctx) + sizeof(crc[0])*num_crcs);
 	if (ctx) {
 		ctx->block_size = block_size;
-		if (final_size != block_size) {
-			ctx->final_size = final_size;
-			ctx->final_crc = crc[--num_crcs];
-		} else {
-			/* If this is 0, we never compare against it. */
-			ctx->final_size = 0;
-		}
+		ctx->tail_size = tail_size;
+		if (tail_size)
+			ctx->tail_crc = crc[--num_crcs];
 
 		/* Technically, 1 << 32 is undefined. */
 		if (crcbits >= 32)
@@ -123,12 +118,12 @@
 	return -1;
 }
 
-static bool final_matches(const struct crc_context *ctx)
+static bool tail_matches(const struct crc_context *ctx)
 {
-	if (ctx->literal_bytes != ctx->final_size)
+	if (ctx->literal_bytes != ctx->tail_size)
 		return false;
 
-	return (ctx->running_crc & ctx->crcmask) == ctx->final_crc;
+	return (ctx->running_crc & ctx->crcmask) == ctx->tail_crc;
 }
 
 static uint32_t crc_add_byte(uint32_t crc, uint8_t newbyte)
@@ -197,7 +192,7 @@
 				old = buf;
 			/* We don't roll this csum, we only look for it after
 			 * a block match.  It's simpler and faster. */
-			if (final_matches(ctx)) {
+			if (tail_matches(ctx)) {
 				crcmatch = ctx->num_crcs;
 				goto have_match;
 			}
@@ -217,7 +212,7 @@
 		have_match:
 			*result = -crcmatch-1;
 			if (crcmatch == ctx->num_crcs)
-				assert(ctx->literal_bytes == ctx->final_size);
+				assert(ctx->literal_bytes == ctx->tail_size);
 			else
 				assert(ctx->literal_bytes == ctx->block_size);
 			ctx->literal_bytes = 0;

=== modified file 'ccan/crcsync/crcsync.h'
--- ccan/crcsync/crcsync.h	2009-04-04 11:35:46 +0000
+++ ccan/crcsync/crcsync.h	2009-04-07 04:14:57 +0000
@@ -19,14 +19,14 @@
 
 /**
  * crc_context_new - allocate and initialize state for crc_find_block
- * @blocksize: the sie of each block
+ * @blocksize: the size of each block
  * @crcbits: the bits valid in the CRCs (<= 32)
- * @crc: array of block crcs
+ * @crc: array of block crcs (including final block, if any)
  * @num_crcs: number of block crcs
- * @final_size: the final block size (<= blocksize).
+ * @tail_size: the size of final partial block, if any (< blocksize).
  *
  * Returns an allocated pointer to the structure for crc_find_block,
- * or NULL.  Makes a copy of @crc and @num_crcs.
+ * or NULL.  Makes a copy of @crc.
  */
 struct crc_context *crc_context_new(size_t blocksize, unsigned crcbits,
 				    const uint32_t crc[], unsigned num_crcs,

=== modified file 'ccan/crcsync/test/run-crash.c'
--- ccan/crcsync/test/run-crash.c	2009-04-04 11:35:46 +0000
+++ ccan/crcsync/test/run-crash.c	2009-04-07 04:17:21 +0000
@@ -55,14 +55,14 @@
 	size_t ndigested;
 	size_t offset = 0;
 	size_t len2 = strlen(data2);
-	size_t finalsize = strlen(data1) % BLOCKSIZE ?: BLOCKSIZE;
+	size_t tailsize = strlen(data1) % BLOCKSIZE;
 	int expected_i = 0;
 
 	plan_tests(ARRAY_SIZE(expected) + 2);
 	crcblocks(&crc_info1, data1, strlen(data1), BLOCKSIZE);
 
 	crcctx = crc_context_new(BLOCKSIZE, 30, crc_info1.crcs, crc_info1.block_count,
-				 finalsize);
+				 tailsize);
 	while ( offset < len2)
 	{
 		ndigested = crc_read_block(crcctx, &result, data2+offset, len2 - offset);

=== modified file 'ccan/crcsync/test/run.c'
--- ccan/crcsync/test/run.c	2009-04-04 12:19:30 +0000
+++ ccan/crcsync/test/run.c	2009-04-07 04:18:48 +0000
@@ -65,17 +65,17 @@
 		      const struct result results[], size_t num_results)
 {
 	struct crc_context *ctx;
-	size_t used, ret, i, curr_literal, finalsize;
+	size_t used, ret, i, curr_literal, tailsize;
 	long result;
 	uint32_t crcs[num_blocks(len1, block_size)];
 
 	crc_of_blocks(buffer1, len1, block_size, 32, crcs);
 
-	finalsize = len1 % block_size ?: block_size;
+	tailsize = len1 % block_size;
 
 	/* Normal method. */
 	ctx = crc_context_new(block_size, 32, crcs, ARRAY_SIZE(crcs),
-			      finalsize);
+			      tailsize);
 
 	curr_literal = 0;
 	for (used = 0, i = 0; used < len2; used += ret) {
@@ -94,7 +94,7 @@
 
 	/* Byte-at-a-time method. */
 	ctx = crc_context_new(block_size, 32, crcs, ARRAY_SIZE(crcs),
-			      finalsize);
+			      tailsize);
 
 	curr_literal = 0;
 	for (used = 0, i = 0; used < len2; used += ret) {



More information about the Http-crcsync mailing list