[fio.git] / crc / test.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "../fio.h"
#include "../gettime.h"
#include "../fio_time.h"
#include "../verify.h"

#include "../crc/md5.h"
#include "../crc/crc64.h"
#include "../crc/crc32.h"
#include "../crc/crc32c.h"
#include "../crc/crc16.h"
#include "../crc/crc7.h"
#include "../crc/sha1.h"
#include "../crc/sha256.h"
#include "../crc/sha512.h"
#include "../crc/xxhash.h"

#include "test.h"

#define CHUNK		131072U
#define NR_CHUNKS	  2048U

struct test_type {
	const char *name;
	unsigned int mask;
	uint64_t (*fn)(void);
};

enum {
	T_MD5		= 1U << 0,
	T_CRC64		= 1U << 1,
	T_CRC32		= 1U << 2,
	T_CRC32C	= 1U << 3,
	T_CRC16		= 1U << 4,
	T_CRC7		= 1U << 5,
	T_SHA1		= 1U << 6,
	T_SHA256	= 1U << 7,
	T_SHA512	= 1U << 8,
	T_XXHASH	= 1U << 9,
};

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)
{
	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);

	fio_gettime(&s, NULL);
	for (i = 0; i < NR_CHUNKS; i++)
		fio_md5_update(&ctx, buf, CHUNK);

	ret = utime_since_now(&s);
	free(buf);
	return ret;
}

static uint64_t t_crc64(void)
{
	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;
}

static uint64_t t_crc32(void)
{
	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;
}

static uint64_t t_crc32c(void)
{
	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);

	ret = utime_since_now(&s);
	free(buf);
	return ret;
}

static uint64_t t_crc16(void)
{
	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_crc16(buf, CHUNK);

	ret = utime_since_now(&s);
	free(buf);
	return ret;
}

static uint64_t t_crc7(void)
{
	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_crc7(buf, CHUNK);

	ret = utime_since_now(&s);
	free(buf);
	return ret;
}

static uint64_t t_sha1(void)
{
	uint32_t sha[5];
	struct fio_sha1_ctx ctx = { .H = sha };
	struct timeval s;
	uint64_t ret;
	void *buf;
	int i;

	fio_sha1_init(&ctx);

	buf = malloc(CHUNK);
	randomize_buf(buf, CHUNK, 0x8989);

	fio_gettime(&s, NULL);
	for (i = 0; i < NR_CHUNKS; i++)
		fio_sha1_update(&ctx, buf, CHUNK);

	ret = utime_since_now(&s);
	free(buf);
	return ret;
}

static uint64_t t_sha256(void)
{
	uint8_t sha[64];
	struct fio_sha256_ctx ctx = { .buf = sha };
	struct timeval s;
	uint64_t ret;
	void *buf;
	int i;

	fio_sha256_init(&ctx);

	buf = malloc(CHUNK);
	randomize_buf(buf, CHUNK, 0x8989);

	fio_gettime(&s, NULL);
	for (i = 0; i < NR_CHUNKS; i++)
		fio_sha256_update(&ctx, buf, CHUNK);

	ret = utime_since_now(&s);
	free(buf);
	return ret;
}

static uint64_t t_sha512(void)
{
	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);

	buf = malloc(CHUNK);
	randomize_buf(buf, CHUNK, 0x8989);

	fio_gettime(&s, NULL);
	for (i = 0; i < NR_CHUNKS; i++)
		fio_sha512_update(&ctx, buf, CHUNK);

	ret = utime_since_now(&s);
	free(buf);
	return ret;
}

static uint64_t t_xxhash(void)
{
	void *state;
	struct timeval s;
	uint64_t ret;
	void *buf;
	int i;

	state = XXH32_init(0x8989);

	buf = malloc(CHUNK);
	randomize_buf(buf, CHUNK, 0x8989);

	fio_gettime(&s, NULL);
	for (i = 0; i < NR_CHUNKS; i++)
		XXH32_update(state, buf, CHUNK);

	XXH32_digest(state);
	ret = utime_since_now(&s);
	free(buf);
	return ret;
}

static struct test_type t[] = {
	{
		.name = "md5",
		.mask = T_MD5,
		.fn = t_md5,
	},
	{
		.name = "crc64",
		.mask = T_CRC64,
		.fn = t_crc64,
	},
	{
		.name = "crc32",
		.mask = T_CRC32,
		.fn = t_crc32,
	},
	{
		.name = "crc32c",
		.mask = T_CRC32C,
		.fn = t_crc32c,
	},
	{
		.name = "crc16",
		.mask = T_CRC16,
		.fn = t_crc16,
	},
	{
		.name = "crc7",
		.mask = T_CRC7,
		.fn = t_crc7,
	},
	{
		.name = "sha1",
		.mask = T_SHA1,
		.fn = t_sha1,
	},
	{
		.name = "sha256",
		.mask = T_SHA256,
		.fn = t_sha256,
	},
	{
		.name = "sha512",
		.mask = T_SHA512,
		.fn = t_sha512,
	},
	{
		.name = "xxhash",
		.mask = T_XXHASH,
		.fn = t_xxhash,
	},
	{
		.name = NULL,
	},
};

static unsigned int get_test_mask(const char *type)
{
	char *ostr, *str = strdup(type);
	unsigned int mask;
	char *name;
	int i;

	ostr = str;
	mask = 0;
	while ((name = strsep(&str, ",")) != NULL) {
		for (i = 0; t[i].name; i++) {
			if (!strcmp(t[i].name, name)) {
				mask |= t[i].mask;
				break;
			}
		}
	}

	free(ostr);
	return mask;
}

static int list_types(void)
{
	int i;

	for (i = 0; t[i].name; i++)
		printf("%s\n", t[i].name);

	return 0;
}

int fio_crctest(const char *type)
{
	unsigned int test_mask = 0;
	uint64_t mb = CHUNK * NR_CHUNKS;
	int i;

	crc32c_intel_probe();

	if (!type)
		test_mask = ~0U;
	else if (!strcmp(type, "help") || !strcmp(type, "list"))
		return list_types();
	else
		test_mask = get_test_mask(type);

	for (i = 0; t[i].name; i++) {
		double mb_sec;
		uint64_t usec;

		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);
	}

	return 0;
}
Commit	Line	Data
fec0f21c JA	1	#include <stdio.h>
	2	#include <stdlib.h>
	3	#include <string.h>
	4
	5	#include "../fio.h"
	6	#include "../gettime.h"
9e52966e	7	#include "../fio_time.h"
fec0f21c JA	8	#include "../verify.h"
	9
	10	#include "../crc/md5.h"
	11	#include "../crc/crc64.h"
	12	#include "../crc/crc32.h"
	13	#include "../crc/crc32c.h"
	14	#include "../crc/crc16.h"
	15	#include "../crc/crc7.h"
	16	#include "../crc/sha1.h"
	17	#include "../crc/sha256.h"
	18	#include "../crc/sha512.h"
844ea602	19	#include "../crc/xxhash.h"
fec0f21c	20
ea1f1da3 JA	21	#include "test.h"
ea1f1da3 JA	22
f7540869 JA	23	#define CHUNK 131072U
f7540869 JA	24	#define NR_CHUNKS 2048U
fec0f21c JA	25
	26	struct test_type {
	27	const char *name;
	28	unsigned int mask;
	29	uint64_t (*fn)(void);
	30	};
	31
	32	enum {
	33	T_MD5 = 1U << 0,
	34	T_CRC64 = 1U << 1,
	35	T_CRC32 = 1U << 2,
	36	T_CRC32C = 1U << 3,
	37	T_CRC16 = 1U << 4,
	38	T_CRC7 = 1U << 5,
	39	T_SHA1 = 1U << 6,
	40	T_SHA256 = 1U << 7,
	41	T_SHA512 = 1U << 8,
844ea602	42	T_XXHASH = 1U << 9,
fec0f21c JA	43	};
	44
	45	static void randomize_buf(void *buf, unsigned int size, int seed)
	46	{
	47	struct frand_state state;
	48
	49	init_rand_seed(&state, seed);
	50	fill_random_buf(&state, buf, size);
	51	}
	52
	53	static uint64_t t_md5(void)
	54	{
	55	uint32_t digest[4];
	56	struct fio_md5_ctx ctx = { .hash = digest };
	57	struct timeval s;
	58	uint64_t ret;
	59	void *buf;
	60	int i;
	61
	62	fio_md5_init(&ctx);
	63
	64	buf = malloc(CHUNK);
	65	randomize_buf(buf, CHUNK, 0x8989);
	66
	67	fio_gettime(&s, NULL);
	68	for (i = 0; i < NR_CHUNKS; i++)
	69	fio_md5_update(&ctx, buf, CHUNK);
	70
	71	ret = utime_since_now(&s);
	72	free(buf);
	73	return ret;
	74	}
	75
	76	static uint64_t t_crc64(void)
	77	{
	78	struct timeval s;
	79	uint64_t ret;
	80	void *buf;
	81	int i;
	82
	83	buf = malloc(CHUNK);
	84	randomize_buf(buf, CHUNK, 0x8989);
	85
	86	fio_gettime(&s, NULL);
	87	for (i = 0; i < NR_CHUNKS; i++)
	88	fio_crc64(buf, CHUNK);
	89
	90	ret = utime_since_now(&s);
	91	free(buf);
	92	return ret;
	93	}
	94
	95	static uint64_t t_crc32(void)
	96	{
	97	struct timeval s;
	98	uint64_t ret;
	99	void *buf;
	100	int i;
	101
	102	buf = malloc(CHUNK);
	103	randomize_buf(buf, CHUNK, 0x8989);
	104
	105	fio_gettime(&s, NULL);
	106	for (i = 0; i < NR_CHUNKS; i++)
107	fio_crc32(buf, CHUNK);
108
109	ret = utime_since_now(&s);
110	free(buf);
111	return ret;
112	}
113
114	static uint64_t t_crc32c(void)
115	{
116	struct timeval s;
117	uint64_t ret;
118	void *buf;
119	int i;
120
121	buf = malloc(CHUNK);
122	randomize_buf(buf, CHUNK, 0x8989);
123
124	fio_gettime(&s, NULL);
125	for (i = 0; i < NR_CHUNKS; i++)
126	fio_crc32c(buf, CHUNK);
127
128	ret = utime_since_now(&s);
129	free(buf);
130	return ret;
131	}
132
133	static uint64_t t_crc16(void)
134	{
135	struct timeval s;
136	uint64_t ret;
137	void *buf;
138	int i;
139
140	buf = malloc(CHUNK);
141	randomize_buf(buf, CHUNK, 0x8989);
142
143	fio_gettime(&s, NULL);
144	for (i = 0; i < NR_CHUNKS; i++)
145	fio_crc16(buf, CHUNK);
146
147	ret = utime_since_now(&s);
148	free(buf);
149	return ret;
150	}
151
152	static uint64_t t_crc7(void)
153	{
154	struct timeval s;
155	uint64_t ret;
156	void *buf;
157	int i;
158
159	buf = malloc(CHUNK);
160	randomize_buf(buf, CHUNK, 0x8989);
161
162	fio_gettime(&s, NULL);
163	for (i = 0; i < NR_CHUNKS; i++)
164	fio_crc7(buf, CHUNK);
165
166	ret = utime_since_now(&s);
167	free(buf);
168	return ret;
169	}
170
171	static uint64_t t_sha1(void)
172	{
173	uint32_t sha[5];
174	struct fio_sha1_ctx ctx = { .H = sha };
175	struct timeval s;
176	uint64_t ret;
177	void *buf;
178	int i;
179
180	fio_sha1_init(&ctx);
181
182	buf = malloc(CHUNK);
183	randomize_buf(buf, CHUNK, 0x8989);
184
185	fio_gettime(&s, NULL);
186	for (i = 0; i < NR_CHUNKS; i++)
187	fio_sha1_update(&ctx, buf, CHUNK);
188
189	ret = utime_since_now(&s);
190	free(buf);
191	return ret;
192	}
193
194	static uint64_t t_sha256(void)
195	{
196	uint8_t sha[64];
197	struct fio_sha256_ctx ctx = { .buf = sha };
198	struct timeval s;
199	uint64_t ret;
200	void *buf;
201	int i;
202
203	fio_sha256_init(&ctx);
204
205	buf = malloc(CHUNK);
206	randomize_buf(buf, CHUNK, 0x8989);
207
208	fio_gettime(&s, NULL);
209	for (i = 0; i < NR_CHUNKS; i++)
210	fio_sha256_update(&ctx, buf, CHUNK);
211
212	ret = utime_since_now(&s);
213	free(buf);
214	return ret;
215	}
216
217	static uint64_t t_sha512(void)
218	{
219	uint8_t sha[128];
220	struct fio_sha512_ctx ctx = { .buf = sha };
221	struct timeval s;
222	uint64_t ret;
223	void *buf;
224	int i;
225
226	fio_sha512_init(&ctx);
227
228	buf = malloc(CHUNK);
229	randomize_buf(buf, CHUNK, 0x8989);
230
231	fio_gettime(&s, NULL);
232	for (i = 0; i < NR_CHUNKS; i++)
233	fio_sha512_update(&ctx, buf, CHUNK);
234
235	ret = utime_since_now(&s);
236	free(buf);
237	return ret;
238	}
239
844ea602 JA	240	static uint64_t t_xxhash(void)
	241	{
	242	void *state;
	243	struct timeval s;
	244	uint64_t ret;
	245	void *buf;
	246	int i;
	247
	248	state = XXH32_init(0x8989);
	249
	250	buf = malloc(CHUNK);
	251	randomize_buf(buf, CHUNK, 0x8989);
	252
	253	fio_gettime(&s, NULL);
	254	for (i = 0; i < NR_CHUNKS; i++)
	255	XXH32_update(state, buf, CHUNK);
	256
	257	XXH32_digest(state);
	258	ret = utime_since_now(&s);
	259	free(buf);
	260	return ret;
	261	}
	262
fec0f21c JA	263	static struct test_type t[] = {
	264	{
	265	.name = "md5",
	266	.mask = T_MD5,
	267	.fn = t_md5,
	268	},
	269	{
	270	.name = "crc64",
	271	.mask = T_CRC64,
	272	.fn = t_crc64,
	273	},
	274	{
	275	.name = "crc32",
	276	.mask = T_CRC32,
	277	.fn = t_crc32,
	278	},
	279	{
	280	.name = "crc32c",
	281	.mask = T_CRC32C,
	282	.fn = t_crc32c,
	283	},
	284	{
	285	.name = "crc16",
	286	.mask = T_CRC16,
	287	.fn = t_crc16,
	288	},
	289	{
	290	.name = "crc7",
	291	.mask = T_CRC7,
	292	.fn = t_crc7,
	293	},
	294	{
	295	.name = "sha1",
	296	.mask = T_SHA1,
	297	.fn = t_sha1,
	298	},
	299	{
	300	.name = "sha256",
	301	.mask = T_SHA256,
	302	.fn = t_sha256,
	303	},
	304	{
	305	.name = "sha512",
	306	.mask = T_SHA512,
	307	.fn = t_sha512,
	308	},
844ea602 JA	309	{
	310	.name = "xxhash",
	311	.mask = T_XXHASH,
	312	.fn = t_xxhash,
	313	},
fec0f21c JA	314	{
	315	.name = NULL,
	316	},
	317	};
	318
	319	static unsigned int get_test_mask(const char *type)
	320	{
	321	char ostr, str = strdup(type);
	322	unsigned int mask;
	323	char *name;
	324	int i;
	325
	326	ostr = str;
	327	mask = 0;
	328	while ((name = strsep(&str, ",")) != NULL) {
	329	for (i = 0; t[i].name; i++) {
f7540869	330	if (!strcmp(t[i].name, name)) {
fec0f21c JA	331	mask \|= t[i].mask;
	332	break;
	333	}
	334	}
	335	}
	336
	337	free(ostr);
	338	return mask;
	339	}
	340
782744ef JA	341	static int list_types(void)
	342	{
	343	int i;
	344
	345	for (i = 0; t[i].name; i++)
	346	printf("%s\n", t[i].name);
	347
	348	return 0;
	349	}
	350
fec0f21c JA	351	int fio_crctest(const char *type)
	352	{
	353	unsigned int test_mask = 0;
	354	uint64_t mb = CHUNK * NR_CHUNKS;
	355	int i;
	356
	357	crc32c_intel_probe();
	358
	359	if (!type)
	360	test_mask = ~0U;
782744ef JA	361	else if (!strcmp(type, "help") \|\| !strcmp(type, "list"))
782744ef JA	362	return list_types();
fec0f21c JA	363	else
	364	test_mask = get_test_mask(type);
	365
	366	for (i = 0; t[i].name; i++) {
	367	double mb_sec;
	368	uint64_t usec;
	369
	370	if (!(t[i].mask & test_mask))
	371	continue;
	372
	373	usec = t[i].fn();
	374	mb_sec = (double) mb / (double) usec;
	375	mb_sec /= (1.024 * 1.024);
	376	printf("%s:\t%.2f MB/sec\n", t[i].name, mb_sec);
	377	}
782744ef	378
fec0f21c JA	379	return 0;
fec0f21c JA	380	}