[test] Add speed tests for digest algorithms

Signed-off-by: Michael Brown <mcb30@ipxe.org>

src/tests/digest_test.c

  *
  */
 
+#include <stdlib.h>
 #include <string.h>
 #include <ipxe/crypto.h>
+#include <ipxe/profile.h>
 #include "digest_test.h"
 
 /**
 	/* Compare against expected output */
 	return ( memcmp ( expected, out, sizeof ( out ) ) == 0 );
 }
+
+/**
+ * Calculate digest algorithm cost
+ *
+ * @v digest		Digest algorithm
+ * @ret cost		Cost (in cycles per byte)
+ */
+unsigned long digest_cost ( struct digest_algorithm *digest ) {
+	static uint8_t random[8192]; /* Too large for stack */
+	uint8_t ctx[digest->ctxsize];
+	uint8_t out[digest->digestsize];
+	union profiler profiler;
+	unsigned long long elapsed;
+	unsigned long cost;
+	unsigned int i;
+
+	/* Fill buffer with pseudo-random data */
+	srand ( 0x1234568 );
+	for ( i = 0 ; i < sizeof ( random ) ; i++ )
+		random[i] = rand();
+
+	/* Time digest calculation */
+	profile ( &profiler );
+	digest_init ( digest, ctx );
+	digest_update ( digest, ctx, random, sizeof ( random ) );
+	digest_final ( digest, ctx, out );
+	elapsed = profile ( &profiler );
+
+	/* Round to nearest whole number of cycles per byte */
+	cost = ( ( elapsed + ( sizeof ( random ) / 2 ) ) / sizeof ( random ) );
+
+	return cost;
+}

src/tests/digest_test.h

 extern int digest_test ( struct digest_algorithm *digest,
 			 struct digest_test_fragments *fragments,
 			 void *data, size_t len, void *expected );
+extern unsigned long digest_cost ( struct digest_algorithm *digest );
 
 /**
  * Report digest test result

src/tests/md5_test.c

 static void md5_test_exec ( void ) {
 	struct digest_algorithm *digest = &md5_algorithm;
 	struct md5_test_vector *test;
+	unsigned long cost;
 	unsigned int i;
 	unsigned int j;
 
+	/* Correctness test */
 	for ( i = 0 ; i < ( sizeof ( md5_test_vectors ) /
 			    sizeof ( md5_test_vectors[0] ) ) ; i++ ) {
 		test = &md5_test_vectors[i];
 				    test->data, test->len, test->digest );
 		}
 	}
+
+	/* Speed test */
+	cost = digest_cost ( digest );
+	DBG ( "MD5 required %ld cycles per byte\n", cost );
 }
 
 /** MD5 self-test */

src/tests/sha1_test.c

 static void sha1_test_exec ( void ) {
 	struct digest_algorithm *digest = &sha1_algorithm;
 	struct sha1_test_vector *test;
+	unsigned long cost;
 	unsigned int i;
 	unsigned int j;
 
+	/* Correctness test */
 	for ( i = 0 ; i < ( sizeof ( sha1_test_vectors ) /
 			    sizeof ( sha1_test_vectors[0] ) ) ; i++ ) {
 		test = &sha1_test_vectors[i];
 				    test->data, test->len, test->digest );
 		}
 	}
+
+	/* Speed test */
+	cost = digest_cost ( digest );
+	DBG ( "SHA1 required %ld cycles per byte\n", cost );
 }
 
 /** SHA-1 self-test */

src/tests/sha256_test.c

 static void sha256_test_exec ( void ) {
 	struct digest_algorithm *digest = &sha256_algorithm;
 	struct sha256_test_vector *test;
+	unsigned long cost;
 	unsigned int i;
 	unsigned int j;
 
+	/* Correctness test */
 	for ( i = 0 ; i < ( sizeof ( sha256_test_vectors ) /
 			    sizeof ( sha256_test_vectors[0] ) ) ; i++ ) {
 		test = &sha256_test_vectors[i];
 				    test->data, test->len, test->digest );
 		}
 	}
+
+	/* Speed test */
+	cost = digest_cost ( digest );
+	DBG ( "SHA256 required %ld cycles per byte\n", cost );
 }
 
 /** SHA-256 self-test */