alg_update_reference_frame: test harness: directly compare functions

Directly run two functions on the same input and check whether they give
the same output; don't just rely on printing a few numbers to the screen
and eyeballing the results.

Author: aklomp

alg/tests/test_alg_update_reference_frame.c

@@ -55,17 +55,59 @@ clean (struct context *ctx)
 	ctx->imgs.motionsize = WIDTH * HEIGHT;
 }
 
+static int
+equal_output (struct context *ctx, int action, void (*func_a)(struct context *, int), void (*func_b)(struct context *, int))
+{
+	int i, ret = 1;
+	struct context cxs[2];
+
+	for (i = 0; i < 2; i++)
+	{
+		/* Copy original context: */
+		memcpy(&cxs[i], ctx, sizeof(*ctx));
+		memcpy(&cxs[i].imgs, &ctx->imgs, sizeof(ctx->imgs));
+
+		/* Copy the original image structures: */
+		#define CPY(x)  cxs[i].imgs.x = malloc(ctx->imgs.size * sizeof(*ctx->imgs.x)); memcpy(cxs[i].imgs.x, ctx->imgs.x, ctx->imgs.size * sizeof(*ctx->imgs.x));
+		CPY(ref)
+		CPY(out)
+		CPY(image_virgin)
+		CPY(smartmask_final)
+		CPY(ref_dyn)
+		#undef CPY
+	}
+	/* Run both functions on their own copy: */
+	func_a(&cxs[0], action);
+	func_b(&cxs[1], action);
+
+	/* Compare image outputs: */
+	#define CMP(x)  if (memcmp(cxs[0].imgs.x, cxs[1].imgs.x, sizeof(*cxs[0].imgs.x)) != 0) { ret = 0; goto out; }
+	CMP(ref)
+	CMP(ref_dyn)
+	#undef CMP
+
+out:	/* Free memory, return: */
+	for (i = 0; i < 2; i++) {
+		free(cxs[i].imgs.ref);
+		free(cxs[i].imgs.out);
+		free(cxs[i].imgs.image_virgin);
+		free(cxs[i].imgs.smartmask_final);
+		free(cxs[i].imgs.ref_dyn);
+	}
+	return ret;
+}
+
 static void
-permutate (int action, void (*func)(struct context *, int))
+permutate (int action, void (*func_a)(struct context *, int), void (*func_b)(struct context *, int))
 {
-	unsigned char ref[16];
-	unsigned char out[16];
-	unsigned char image_virgin[16];
-	unsigned char smartmask_final[16];
-	uint16_t ref_dyn[16];
+	#define STRIPSZ 41
+
+	unsigned char ref[STRIPSZ];
+	unsigned char out[STRIPSZ];
+	unsigned char image_virgin[STRIPSZ];
+	unsigned char smartmask_final[STRIPSZ];
+	uint16_t ref_dyn[STRIPSZ];
 	struct context ctx;
-	unsigned int ref_cksum;
-	unsigned int ref_dyn_cksum;
 
 	int i, iter_ref_dyn, iter_smartmask, iter_image_virgin, iter_out, iter_ref;
 
@@ -76,8 +118,8 @@ permutate (int action, void (*func)(struct context *, int))
 	ctx.imgs.image_virgin = image_virgin;
 	ctx.imgs.smartmask_final = smartmask_final;
 	ctx.imgs.ref_dyn = ref_dyn;
-	ctx.imgs.size = 16;
-	ctx.imgs.motionsize = 16;
+	ctx.imgs.size = STRIPSZ;
+	ctx.imgs.motionsize = STRIPSZ;
 
 	/* For the purposes of the routine, smartmask is zero or nonzero: */
 	for (iter_smartmask = 0; iter_smartmask < 2; iter_smartmask++) {
@@ -87,35 +129,35 @@ permutate (int action, void (*func)(struct context *, int))
 		for (iter_out = 0; iter_out < 2; iter_out++) {
 			memset(out, iter_out, ctx.imgs.size);
 
-			ref_cksum = 0;
-			ref_dyn_cksum = 0;
-
 			for (iter_image_virgin = 0; iter_image_virgin < 256; iter_image_virgin++) {
-				memset(image_virgin, iter_image_virgin, ctx.imgs.size);
-
+				for (i = 0; i < ctx.imgs.size; i++) {
+					image_virgin[i] = iter_image_virgin + i;
+				}
 				/* ref_dyn has a limited range: */
 				for (iter_ref_dyn = 0; iter_ref_dyn < 10; iter_ref_dyn++) {
-					for (i = 0; i < 16; i++) {
-						ref_dyn[i] = iter_ref_dyn + 1;
+					for (i = 0; i < ctx.imgs.size; i++) {
+						ref_dyn[i] = iter_ref_dyn + i;
 					}
 					for (iter_ref = 0; iter_ref < 256; iter_ref++) {
-						memset(ref, iter_ref, ctx.imgs.size);
-						func(&ctx, action);
-						ref_cksum += ref[0];
-
-						for (i = 0; i < 16; i++) {
-							ref_dyn_cksum += ref_dyn[i];
+						for (i = 0; i < ctx.imgs.size; i++) {
+							ref[i] = iter_ref + i;
+						}
+						/* For this permutation, check that both functions
+						 * return the same output data: */
+						if (equal_output(&ctx, action, func_a, func_b) == 0) {
+							printf("Functions do NOT match!\n");
+							return;
 						}
 					}
 				}
 			}
-			printf("%d %d\n", ref_cksum, ref_dyn_cksum);
 		}
 	}
+	printf("Functions MATCH\n");
 }
 
 static void
-testsuite (char *name, struct context *ctx, int action, void (*func)(struct context *, int))
+timing (char *name, struct context *ctx, int action, void (*func)(struct context *, int))
 {
 	int i;
 	float total_time = 0.0f;
@@ -132,8 +174,6 @@ testsuite (char *name, struct context *ctx, int action, void (*func)(struct cont
 
 	/* Print bogus value to prevent the loop from being optimized out: */
 	printf("Value: %d\nTime: %.4f sec\n", ctx->imgs.ref[0], total_time);
-
-	permutate(action, func);
 }
 
 #define UPDATE_REF_FRAME  1
@@ -151,9 +191,12 @@ main ()
 
 	init(&ctx);
 
-	testsuite("plain", &ctx, UPDATE_REF_FRAME, alg_update_reference_frame_plain);
-	testsuite("plain, SSE2 algorithm demo", &ctx, UPDATE_REF_FRAME, alg_update_reference_frame_sse2_algo);
-	testsuite("SSE2", &ctx, UPDATE_REF_FRAME, alg_update_reference_frame_sse2);
+	timing("plain", &ctx, UPDATE_REF_FRAME, alg_update_reference_frame_plain);
+	timing("plain, SSE2 algorithm demo", &ctx, UPDATE_REF_FRAME, alg_update_reference_frame_sse2_algo);
+	timing("SSE2", &ctx, UPDATE_REF_FRAME, alg_update_reference_frame_sse2);
+
+	permutate(UPDATE_REF_FRAME, alg_update_reference_frame_plain, alg_update_reference_frame_sse2_algo);
+	permutate(UPDATE_REF_FRAME, alg_update_reference_frame_plain, alg_update_reference_frame_sse2);
 
 	free(ctx.imgs.ref);
 	free(ctx.imgs.out);