X-Git-Url: https://git.kernel.dk/?a=blobdiff_plain;f=crc%2Ftest.c;h=b119872625864eae504123faa47157ee61984d4e;hb=13bddad990ba2c268415e9dcbdc5dfa40f7c6cd3;hp=2f6d9ee7f430c1a05a5d00c328b8a35e33e6fc2d;hpb=782744ef60b7ed47a529d30b9f8e0c528c436fdb;p=fio.git

diff --git a/crc/test.c b/crc/test.c
index 2f6d9ee7..b1198726 100644
--- a/crc/test.c
+++ b/crc/test.c
@@ -4,7 +4,7 @@
 
 #include "../fio.h"
 #include "../gettime.h"
-#include "../time.h"
+#include "../fio_time.h"
 #include "../verify.h"
 
 #include "../crc/md5.h"
@@ -16,6 +16,13 @@
 #include "../crc/sha1.h"
 #include "../crc/sha256.h"
 #include "../crc/sha512.h"
+#include "../crc/sha3.h"
+#include "../crc/xxhash.h"
+#include "../crc/murmur3.h"
+#include "../crc/fnv.h"
+#include "../hash.h"
+
+#include "test.h"
 
 #define CHUNK		131072U
 #define NR_CHUNKS	  2048U
@@ -23,7 +30,8 @@
 struct test_type {
 	const char *name;
 	unsigned int mask;
-	uint64_t (*fn)(void);
+	void (*fn)(struct test_type *, void *, size_t);
+	uint32_t output;
 };
 
 enum {
@@ -36,201 +44,201 @@ enum {
 	T_SHA1		= 1U << 6,
 	T_SHA256	= 1U << 7,
 	T_SHA512	= 1U << 8,
+	T_XXHASH	= 1U << 9,
+	T_MURMUR3	= 1U << 10,
+	T_JHASH		= 1U << 11,
+	T_FNV		= 1U << 12,
+	T_SHA3_224	= 1U << 13,
+	T_SHA3_256	= 1U << 14,
+	T_SHA3_384	= 1U << 15,
+	T_SHA3_512	= 1U << 16,
 };
 
-static void randomize_buf(void *buf, unsigned int size, int seed)
-{
-	struct frand_state state;
-
-	init_rand_seed(&state, seed);
-	fill_random_buf(&state, buf, size);
-}
-
-static uint64_t t_md5(void)
+static void t_md5(struct test_type *t, void *buf, size_t size)
 {
 	uint32_t digest[4];
 	struct fio_md5_ctx ctx = { .hash = digest };
-	struct timeval s;
-	uint64_t ret;
-	void *buf;
 	int i;
 
 	fio_md5_init(&ctx);
 
-	buf = malloc(CHUNK);
-	randomize_buf(buf, CHUNK, 0x8989);
+	for (i = 0; i < NR_CHUNKS; i++) {
+		fio_md5_update(&ctx, buf, size);
+		fio_md5_final(&ctx);
+	}
+}
 
-	fio_gettime(&s, NULL);
-	for (i = 0; i < NR_CHUNKS; i++)
-		fio_md5_update(&ctx, buf, CHUNK);
+static void t_crc64(struct test_type *t, void *buf, size_t size)
+{
+	int i;
 
-	ret = utime_since_now(&s);
-	free(buf);
-	return ret;
+	for (i = 0; i < NR_CHUNKS; i++)
+		t->output += fio_crc64(buf, size);
 }
 
-static uint64_t t_crc64(void)
+static void t_crc32(struct test_type *t, void *buf, size_t size)
 {
-	struct timeval s;
-	uint64_t ret;
-	void *buf;
 	int i;
 
-	buf = malloc(CHUNK);
-	randomize_buf(buf, CHUNK, 0x8989);
-
-	fio_gettime(&s, NULL);
 	for (i = 0; i < NR_CHUNKS; i++)
-		fio_crc64(buf, CHUNK);
-
-	ret = utime_since_now(&s);
-	free(buf);
-	return ret;
+		t->output += fio_crc32(buf, size);
 }
 
-static uint64_t t_crc32(void)
+static void t_crc32c(struct test_type *t, void *buf, size_t size)
 {
-	struct timeval s;
-	uint64_t ret;
-	void *buf;
 	int i;
 
-	buf = malloc(CHUNK);
-	randomize_buf(buf, CHUNK, 0x8989);
-
-	fio_gettime(&s, NULL);
 	for (i = 0; i < NR_CHUNKS; i++)
-		fio_crc32(buf, CHUNK);
-
-	ret = utime_since_now(&s);
-	free(buf);
-	return ret;
+		t->output += fio_crc32c(buf, size);
 }
 
-static uint64_t t_crc32c(void)
+static void t_crc16(struct test_type *t, void *buf, size_t size)
 {
-	struct timeval s;
-	uint64_t ret;
-	void *buf;
 	int i;
 
-	buf = malloc(CHUNK);
-	randomize_buf(buf, CHUNK, 0x8989);
-
-	fio_gettime(&s, NULL);
 	for (i = 0; i < NR_CHUNKS; i++)
-		fio_crc32c(buf, CHUNK);
+		t->output += fio_crc16(buf, size);
+}
 
-	ret = utime_since_now(&s);
-	free(buf);
-	return ret;
+static void t_crc7(struct test_type *t, void *buf, size_t size)
+{
+	int i;
+
+	for (i = 0; i < NR_CHUNKS; i++)
+		t->output += fio_crc7(buf, size);
 }
 
-static uint64_t t_crc16(void)
+static void t_sha1(struct test_type *t, void *buf, size_t size)
 {
-	struct timeval s;
-	uint64_t ret;
-	void *buf;
+	uint32_t sha[5];
+	struct fio_sha1_ctx ctx = { .H = sha };
 	int i;
 
-	buf = malloc(CHUNK);
-	randomize_buf(buf, CHUNK, 0x8989);
+	fio_sha1_init(&ctx);
 
-	fio_gettime(&s, NULL);
-	for (i = 0; i < NR_CHUNKS; i++)
-		fio_crc16(buf, CHUNK);
+	for (i = 0; i < NR_CHUNKS; i++) {
+		fio_sha1_update(&ctx, buf, size);
+		fio_sha1_final(&ctx);
+	}
+}
 
-	ret = utime_since_now(&s);
-	free(buf);
-	return ret;
+static void t_sha256(struct test_type *t, void *buf, size_t size)
+{
+	uint8_t sha[64];
+	struct fio_sha256_ctx ctx = { .buf = sha };
+	int i;
+
+	fio_sha256_init(&ctx);
+
+	for (i = 0; i < NR_CHUNKS; i++) {
+		fio_sha256_update(&ctx, buf, size);
+		fio_sha256_final(&ctx);
+	}
 }
 
-static uint64_t t_crc7(void)
+static void t_sha512(struct test_type *t, void *buf, size_t size)
 {
-	struct timeval s;
-	uint64_t ret;
-	void *buf;
+	uint8_t sha[128];
+	struct fio_sha512_ctx ctx = { .buf = sha };
 	int i;
 
-	buf = malloc(CHUNK);
-	randomize_buf(buf, CHUNK, 0x8989);
+	fio_sha512_init(&ctx);
 
-	fio_gettime(&s, NULL);
 	for (i = 0; i < NR_CHUNKS; i++)
-		fio_crc7(buf, CHUNK);
+		fio_sha512_update(&ctx, buf, size);
+}
 
-	ret = utime_since_now(&s);
-	free(buf);
-	return ret;
+static void t_sha3_224(struct test_type *t, void *buf, size_t size)
+{
+	uint8_t sha[SHA3_224_DIGEST_SIZE];
+	struct fio_sha3_ctx ctx = { .sha = sha };
+	int i;
+
+	fio_sha3_224_init(&ctx);
+
+	for (i = 0; i < NR_CHUNKS; i++) {
+		fio_sha3_update(&ctx, buf, size);
+		fio_sha3_final(&ctx);
+	}
 }
 
-static uint64_t t_sha1(void)
+static void t_sha3_256(struct test_type *t, void *buf, size_t size)
 {
-	uint32_t sha[5];
-	struct fio_sha1_ctx ctx = { .H = sha };
-	struct timeval s;
-	uint64_t ret;
-	void *buf;
+	uint8_t sha[SHA3_256_DIGEST_SIZE];
+	struct fio_sha3_ctx ctx = { .sha = sha };
 	int i;
 
-	fio_sha1_init(&ctx);
+	fio_sha3_256_init(&ctx);
 
-	buf = malloc(CHUNK);
-	randomize_buf(buf, CHUNK, 0x8989);
+	for (i = 0; i < NR_CHUNKS; i++) {
+		fio_sha3_update(&ctx, buf, size);
+		fio_sha3_final(&ctx);
+	}
+}
 
-	fio_gettime(&s, NULL);
-	for (i = 0; i < NR_CHUNKS; i++)
-		fio_sha1_update(&ctx, buf, CHUNK);
+static void t_sha3_384(struct test_type *t, void *buf, size_t size)
+{
+	uint8_t sha[SHA3_384_DIGEST_SIZE];
+	struct fio_sha3_ctx ctx = { .sha = sha };
+	int i;
 
-	ret = utime_since_now(&s);
-	free(buf);
-	return ret;
+	fio_sha3_384_init(&ctx);
+
+	for (i = 0; i < NR_CHUNKS; i++) {
+		fio_sha3_update(&ctx, buf, size);
+		fio_sha3_final(&ctx);
+	}
 }
 
-static uint64_t t_sha256(void)
+static void t_sha3_512(struct test_type *t, void *buf, size_t size)
 {
-	uint8_t sha[64];
-	struct fio_sha256_ctx ctx = { .buf = sha };
-	struct timeval s;
-	uint64_t ret;
-	void *buf;
+	uint8_t sha[SHA3_512_DIGEST_SIZE];
+	struct fio_sha3_ctx ctx = { .sha = sha };
 	int i;
 
-	fio_sha256_init(&ctx);
+	fio_sha3_512_init(&ctx);
 
-	buf = malloc(CHUNK);
-	randomize_buf(buf, CHUNK, 0x8989);
+	for (i = 0; i < NR_CHUNKS; i++) {
+		fio_sha3_update(&ctx, buf, size);
+		fio_sha3_final(&ctx);
+	}
+}
+
+static void t_murmur3(struct test_type *t, void *buf, size_t size)
+{
+	int i;
 
-	fio_gettime(&s, NULL);
 	for (i = 0; i < NR_CHUNKS; i++)
-		fio_sha256_update(&ctx, buf, CHUNK);
+		t->output += murmurhash3(buf, size, 0x8989);
+}
 
-	ret = utime_since_now(&s);
-	free(buf);
-	return ret;
+static void t_jhash(struct test_type *t, void *buf, size_t size)
+{
+	int i;
+
+	for (i = 0; i < NR_CHUNKS; i++)
+		t->output += jhash(buf, size, 0x8989);
 }
 
-static uint64_t t_sha512(void)
+static void t_fnv(struct test_type *t, void *buf, size_t size)
 {
-	uint8_t sha[128];
-	struct fio_sha512_ctx ctx = { .buf = sha };
-	struct timeval s;
-	uint64_t ret;
-	void *buf;
 	int i;
 
-	fio_sha512_init(&ctx);
+	for (i = 0; i < NR_CHUNKS; i++)
+		t->output += fnv(buf, size, 0x8989);
+}
 
-	buf = malloc(CHUNK);
-	randomize_buf(buf, CHUNK, 0x8989);
+static void t_xxhash(struct test_type *t, void *buf, size_t size)
+{
+	void *state;
+	int i;
+
+	state = XXH32_init(0x8989);
 
-	fio_gettime(&s, NULL);
 	for (i = 0; i < NR_CHUNKS; i++)
-		fio_sha512_update(&ctx, buf, CHUNK);
+		XXH32_update(state, buf, size);
 
-	ret = utime_since_now(&s);
-	free(buf);
-	return ret;
+	t->output = XXH32_digest(state);
 }
 
 static struct test_type t[] = {
@@ -279,6 +287,46 @@ static struct test_type t[] = {
 		.mask = T_SHA512,
 		.fn = t_sha512,
 	},
+	{
+		.name = "xxhash",
+		.mask = T_XXHASH,
+		.fn = t_xxhash,
+	},
+	{
+		.name = "murmur3",
+		.mask = T_MURMUR3,
+		.fn = t_murmur3,
+	},
+	{
+		.name = "jhash",
+		.mask = T_JHASH,
+		.fn = t_jhash,
+	},
+	{
+		.name = "fnv",
+		.mask = T_FNV,
+		.fn = t_fnv,
+	},
+	{
+		.name = "sha3-224",
+		.mask = T_SHA3_224,
+		.fn = t_sha3_224,
+	},
+	{
+		.name = "sha3-256",
+		.mask = T_SHA3_256,
+		.fn = t_sha3_256,
+	},
+	{
+		.name = "sha3-384",
+		.mask = T_SHA3_384,
+		.fn = t_sha3_384,
+	},
+	{
+		.name = "sha3-512",
+		.mask = T_SHA3_512,
+		.fn = t_sha3_512,
+	},
 	{
 		.name = NULL,
 	},
@@ -313,15 +361,18 @@ static int list_types(void)
 	for (i = 0; t[i].name; i++)
 		printf("%s\n", t[i].name);
 
-	return 0;
+	return 1;
 }
 
 int fio_crctest(const char *type)
 {
 	unsigned int test_mask = 0;
 	uint64_t mb = CHUNK * NR_CHUNKS;
-	int i;
+	struct frand_state state;
+	int i, first = 1;
+	void *buf;
 
+	crc32c_arm64_probe();
 	crc32c_intel_probe();
 
 	if (!type)
@@ -331,18 +382,50 @@ int fio_crctest(const char *type)
 	else
 		test_mask = get_test_mask(type);
 
+	if (!test_mask) {
+		fprintf(stderr, "fio: unknown hash `%s`. Available:\n", type);
+		return list_types();
+	}
+
+	buf = malloc(CHUNK);
+	init_rand_seed(&state, 0x8989, 0);
+	fill_random_buf(&state, buf, CHUNK);
+
 	for (i = 0; t[i].name; i++) {
+		struct timespec ts;
 		double mb_sec;
 		uint64_t usec;
+		char pre[3];
 
 		if (!(t[i].mask & test_mask))
 			continue;
 
-		usec = t[i].fn();
-		mb_sec = (double) mb / (double) usec;
-		mb_sec /= (1.024 * 1.024);
-		printf("%s:\t%.2f MB/sec\n", t[i].name, mb_sec);
+		/*
+		 * For first run, make sure CPUs are spun up and that
+		 * we've touched the data.
+		 */
+		if (first) {
+			usec_spin(100000);
+			t[i].fn(&t[i], buf, CHUNK);
+		}
+
+		fio_gettime(&ts, NULL);
+		t[i].fn(&t[i], buf, CHUNK);
+		usec = utime_since_now(&ts);
+
+		if (usec) {
+			mb_sec = (double) mb / (double) usec;
+			mb_sec /= (1.024 * 1.024);
+			if (strlen(t[i].name) >= 7)
+				sprintf(pre, "\t");
+			else
+				sprintf(pre, "\t\t");
+			printf("%s:%s%8.2f MiB/sec\n", t[i].name, pre, mb_sec);
+		} else
+			printf("%s:inf MiB/sec\n", t[i].name);
+		first = 0;
 	}
 
+	free(buf);
 	return 0;
 }