SIMD implementation of vdev_raidz generate and reconstruct routines

This is a new implementation of RAIDZ1/2/3 routines using x86_64
scalar, SSE, and AVX2 instruction sets. Included are 3 parity
generation routines (P, PQ, and PQR) and 7 reconstruction routines,
for all RAIDZ level. On module load, a quick benchmark of supported
routines will select the fastest for each operation and they will
be used at runtime. Original implementation is still present and
can be selected via module parameter.

Patch contains:
- specialized gen/rec routines for all RAIDZ levels,
- new scalar raidz implementation (unrolled),
- two x86_64 SIMD implementations (SSE and AVX2 instructions sets),
- fastest routines selected on module load (benchmark).
- cmd/raidz_test - verify and benchmark all implementations
- added raidz_test to the ZFS Test Suite

New zfs module parameters:
- zfs_vdev_raidz_impl (str): selects the implementation to use. On
  module load, the parameter will only accept first 3 options, and
  the other implementations can be set once module is finished
  loading. Possible values for this option are:
    "fastest" - use the fastest math available
    "original" - use the original raidz code
    "scalar" - new scalar impl
    "sse" - new SSE impl if available
    "avx2" - new AVX2 impl if available

See contents of `/sys/module/zfs/parameters/zfs_vdev_raidz_impl` to
get the list of supported values. If an implementation is not supported
on the system, it will not be shown. Currently selected option is
enclosed in `[]`.

Signed-off-by: Gvozden Neskovic <[email protected]>
Signed-off-by: Brian Behlendorf <[email protected]>
Closes #4328

6 files changed, 1140 insertions, 1 deletions

diff --git a/cmd/Makefile.am b/cmd/Makefile.am
index 05f42a556..04aa7c633 100644
--- a/cmd/Makefile.am
+++ b/cmd/Makefile.am
@@ -1,3 +1,3 @@
 SUBDIRS  = zfs zpool zdb zhack zinject zstreamdump ztest zpios
 SUBDIRS += mount_zfs fsck_zfs zvol_id vdev_id arcstat dbufstat zed
-SUBDIRS += arc_summary
+SUBDIRS += arc_summary raidz_test
diff --git a/cmd/raidz_test/.gitignore b/cmd/raidz_test/.gitignore
new file mode 100644
index 000000000..f8b83d9cc
--- /dev/null
+++ b/cmd/raidz_test/.gitignore
@@ -0,0 +1 @@
+/raidz_test
diff --git a/cmd/raidz_test/Makefile.am b/cmd/raidz_test/Makefile.am
new file mode 100644
index 000000000..23ad08ad9
--- /dev/null
+++ b/cmd/raidz_test/Makefile.am
@@ -0,0 +1,21 @@
+include $(top_srcdir)/config/Rules.am
+
+AM_CFLAGS += $(DEBUG_STACKFLAGS) $(FRAME_LARGER_THAN)
+AM_CPPFLAGS += -DDEBUG
+
+DEFAULT_INCLUDES += \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/lib/libspl/include
+
+bin_PROGRAMS = raidz_test
+
+raidz_test_SOURCES = \
+	raidz_test.h \
+	raidz_test.c \
+	raidz_bench.c
+
+raidz_test_LDADD = \
+	$(top_builddir)/lib/libuutil/libuutil.la \
+	$(top_builddir)/lib/libzpool/libzpool.la
+
+raidz_test_LDADD += -lm -ldl
diff --git a/cmd/raidz_test/raidz_bench.c b/cmd/raidz_test/raidz_bench.c
new file mode 100644
index 000000000..040171a38
--- /dev/null
+++ b/cmd/raidz_test/raidz_bench.c
@@ -0,0 +1,241 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (C) 2016 Gvozden Nešković. All rights reserved.
+ */
+
+#include <sys/zfs_context.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <sys/zio.h>
+#include <sys/vdev_raidz.h>
+#include <sys/vdev_raidz_impl.h>
+#include <stdio.h>
+
+#include <sys/time.h>
+#include <sys/resource.h>
+
+#include "raidz_test.h"
+
+#define	GEN_BENCH_MEMORY	(((uint64_t)1ULL)<<32)
+#define	REC_BENCH_MEMORY	(((uint64_t)1ULL)<<29)
+#define	BENCH_ASHIFT		12
+#define	MIN_CS_SHIFT		BENCH_ASHIFT
+#define	MAX_CS_SHIFT		SPA_MAXBLOCKSHIFT
+
+
+static zio_t zio_bench;
+static raidz_map_t *rm_bench;
+static size_t max_data_size = SPA_MAXBLOCKSIZE;
+
+static void
+bench_init_raidz_map(void)
+{
+	zio_bench.io_offset = 0;
+	zio_bench.io_size = max_data_size;
+
+	/*
+	 * To permit larger column sizes these have to be done
+	 * allocated using aligned alloc instead of zio_data_buf_alloc
+	 */
+	zio_bench.io_data = raidz_alloc(max_data_size);
+
+	init_zio_data(&zio_bench);
+}
+
+static void
+bench_fini_raidz_maps(void)
+{
+	/* tear down golden zio */
+	raidz_free(zio_bench.io_data, max_data_size);
+	bzero(&zio_bench, sizeof (zio_t));
+}
+
+static double
+get_time_diff(struct rusage *start, struct rusage *stop)
+{
+	return (((double)stop->ru_utime.tv_sec * (double)MICROSEC +
+		(double)stop->ru_utime.tv_usec) -
+		((double)start->ru_utime.tv_sec * (double)MICROSEC +
+		(double)start->ru_utime.tv_usec)) / (double)MICROSEC;
+}
+
+static inline void
+run_gen_bench_impl(const char *impl)
+{
+	int fn, ncols;
+	uint64_t ds, iter_cnt, iter, disksize;
+	struct rusage start, stop;
+	double elapsed, d_bw;
+
+	/* Benchmark generate functions */
+	for (fn = 0; fn < RAIDZ_GEN_NUM; fn++) {
+
+		for (ds = MIN_CS_SHIFT; ds <= MAX_CS_SHIFT; ds++) {
+
+			/* create suitable raidz_map */
+			ncols = rto_opts.rto_dcols + fn + 1;
+			zio_bench.io_size = 1ULL << ds;
+			rm_bench = vdev_raidz_map_alloc(&zio_bench,
+			    BENCH_ASHIFT, ncols, fn+1);
+
+			/* estimate iteration count */
+			iter_cnt = GEN_BENCH_MEMORY;
+			iter_cnt /= zio_bench.io_size;
+
+			getrusage(RUSAGE_THREAD, &start);
+			for (iter = 0; iter < iter_cnt; iter++)
+				vdev_raidz_generate_parity(rm_bench);
+			getrusage(RUSAGE_THREAD, &stop);
+
+			elapsed = get_time_diff(&start, &stop);
+			disksize = (1ULL << ds) / rto_opts.rto_dcols;
+			d_bw = (double)iter_cnt * (double)disksize;
+			d_bw /= (1024.0 * 1024.0 * elapsed);
+
+			LOG(D_ALL, "%10s, %8s, %zu, %10llu, %lf, %lf, %u\n",
+			    impl,
+			    raidz_gen_name[fn],
+			    rto_opts.rto_dcols,
+			    (1ULL<<ds),
+			    d_bw,
+			    d_bw * (double)(ncols),
+			    (unsigned) iter_cnt);
+
+			vdev_raidz_map_free(rm_bench);
+		}
+	}
+}
+
+void
+run_gen_bench(void)
+{
+	char **impl_name;
+
+	LOG(D_INFO, DBLSEP "\nBenchmarking parity generation...\n\n");
+	LOG(D_ALL, "impl, math, dcols, iosize, disk_bw, total_bw, iter\n");
+
+	for (impl_name = (char **)raidz_impl_names; *impl_name != NULL;
+	    impl_name++) {
+
+		if (vdev_raidz_impl_set(*impl_name) != 0)
+			continue;
+
+		run_gen_bench_impl(*impl_name);
+	}
+}
+
+static void
+run_rec_bench_impl(const char *impl)
+{
+	struct rusage start, stop;
+	int fn, ncols, nbad;
+	uint64_t ds, iter_cnt, iter, disksize;
+	double elapsed, d_bw;
+	static const int tgt[7][3] = {
+		{1, 2, 3},	/* rec_p:   bad QR & D[0]	*/
+		{0, 2, 3},	/* rec_q:   bad PR & D[0]	*/
+		{0, 1, 3},	/* rec_r:   bad PQ & D[0]	*/
+		{2, 3, 4},	/* rec_pq:  bad R  & D[0][1]	*/
+		{1, 3, 4},	/* rec_pr:  bad Q  & D[0][1]	*/
+		{0, 3, 4},	/* rec_qr:  bad P  & D[0][1]	*/
+		{3, 4, 5}	/* rec_pqr: bad    & D[0][1][2] */
+	};
+
+	for (fn = 0; fn < RAIDZ_REC_NUM; fn++) {
+		for (ds = MIN_CS_SHIFT; ds <= MAX_CS_SHIFT; ds++) {
+
+			/* create suitable raidz_map */
+			ncols = rto_opts.rto_dcols + PARITY_PQR;
+			zio_bench.io_size = 1ULL << ds;
+
+			/*
+			 * raidz block is too short to test
+			 * the requested method
+			 */
+			if (zio_bench.io_size / rto_opts.rto_dcols <
+			    (1ULL << BENCH_ASHIFT))
+				continue;
+
+			rm_bench = vdev_raidz_map_alloc(&zio_bench,
+				BENCH_ASHIFT, ncols, PARITY_PQR);
+
+			/* estimate iteration count */
+			iter_cnt = (REC_BENCH_MEMORY);
+			iter_cnt /= zio_bench.io_size;
+
+			/* calculate how many bad columns there are */
+			nbad = MIN(3, raidz_ncols(rm_bench) -
+			    raidz_parity(rm_bench));
+
+			getrusage(RUSAGE_THREAD, &start);
+			for (iter = 0; iter < iter_cnt; iter++)
+				vdev_raidz_reconstruct(rm_bench, tgt[fn], nbad);
+			getrusage(RUSAGE_THREAD, &stop);
+
+			elapsed = get_time_diff(&start, &stop);
+			disksize = (1ULL << ds) / rto_opts.rto_dcols;
+			d_bw = (double)iter_cnt * (double)(disksize);
+			d_bw /= (1024.0 * 1024.0 * elapsed);
+
+			LOG(D_ALL, "%10s, %8s, %zu, %10llu, %lf, %lf, %u\n",
+			    impl,
+			    raidz_rec_name[fn],
+			    rto_opts.rto_dcols,
+			    (1ULL<<ds),
+			    d_bw,
+			    d_bw * (double)ncols,
+			    (unsigned) iter_cnt);
+
+			vdev_raidz_map_free(rm_bench);
+		}
+	}
+}
+
+void
+run_rec_bench(void)
+{
+	char **impl_name;
+
+	LOG(D_INFO, DBLSEP "\nBenchmarking data reconstruction...\n\n");
+	LOG(D_ALL, "impl, math, dcols, iosize, disk_bw, total_bw, iter\n");
+
+	for (impl_name = (char **)raidz_impl_names; *impl_name != NULL;
+	    impl_name++) {
+
+		if (vdev_raidz_impl_set(*impl_name) != 0)
+			continue;
+
+		run_rec_bench_impl(*impl_name);
+	}
+}
+
+void
+run_raidz_benchmark(void)
+{
+	bench_init_raidz_map();
+
+	run_gen_bench();
+	run_rec_bench();
+
+	bench_fini_raidz_maps();
+}
diff --git a/cmd/raidz_test/raidz_test.c b/cmd/raidz_test/raidz_test.c
new file mode 100644
index 000000000..e592cf7e8
--- /dev/null
+++ b/cmd/raidz_test/raidz_test.c
@@ -0,0 +1,770 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (C) 2016 Gvozden Nešković. All rights reserved.
+ */
+
+#include <sys/zfs_context.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <sys/zio.h>
+#include <umem.h>
+#include <sys/vdev_raidz.h>
+#include <sys/vdev_raidz_impl.h>
+#include <assert.h>
+#include <stdio.h>
+#include "raidz_test.h"
+
+static int *rand_data;
+raidz_test_opts_t rto_opts;
+
+static char gdb[256];
+static const char gdb_tmpl[] = "gdb -ex \"set pagination 0\" -p %d";
+
+static void sig_handler(int signo)
+{
+	struct sigaction action;
+	/*
+	 * Restore default action and re-raise signal so SIGSEGV and
+	 * SIGABRT can trigger a core dump.
+	 */
+	action.sa_handler = SIG_DFL;
+	sigemptyset(&action.sa_mask);
+	action.sa_flags = 0;
+	(void) sigaction(signo, &action, NULL);
+
+	if (rto_opts.rto_gdb)
+		if (system(gdb));
+
+	raise(signo);
+}
+
+static void print_opts(raidz_test_opts_t *opts, boolean_t force)
+{
+	char *verbose;
+	switch (opts->rto_v) {
+		case 0:
+			verbose = "no";
+			break;
+		case 1:
+			verbose = "info";
+			break;
+		default:
+			verbose = "debug";
+			break;
+	}
+
+	if (force || opts->rto_v >= D_INFO) {
+		(void) fprintf(stdout, DBLSEP "Running with options:\n"
+		    "  (-a) zio ashift                   : %zu\n"
+		    "  (-o) zio offset                   : 1 << %zu\n"
+		    "  (-d) number of raidz data columns : %zu\n"
+		    "  (-s) size of DATA                 : 1 << %zu\n"
+		    "  (-S) sweep parameters             : %s \n"
+		    "  (-v) verbose                      : %s \n\n",
+		    opts->rto_ashift,			/* -a */
+		    ilog2(opts->rto_offset),		/* -o */
+		    opts->rto_dcols,			/* -d */
+		    ilog2(opts->rto_dsize),		/* -s */
+		    opts->rto_sweep ? "yes" : "no",	/* -S */
+		    verbose 				/* -v */
+		);
+	}
+}
+
+static void usage(boolean_t requested)
+{
+	const raidz_test_opts_t *o = &rto_opts_defaults;
+
+	FILE *fp = requested ? stdout : stderr;
+
+	(void) fprintf(fp, "Usage:\n"
+	"\t[-a zio ashift (default: %zu)]\n"
+	"\t[-o zio offset, exponent radix 2 (default: %zu)]\n"
+	"\t[-d number of raidz data columns (default: %zu)]\n"
+	"\t[-s zio size, exponent radix 2 (default: %zu)]\n"
+	"\t[-S parameter sweep (default: %s)]\n"
+	"\t[-t timeout for parameter sweep test]\n"
+	"\t[-B benchmark all raidz implementations]\n"
+	"\t[-v increase verbosity (default: %zu)]\n"
+	"\t[-h (print help)]\n"
+	"\t[-T test the test, see if failure would be detected]\n"
+	"\t[-D debug (attach gdb on SIGSEGV)]\n"
+	"",
+	o->rto_ashift,				/* -a */
+	ilog2(o->rto_offset),			/* -o */
+	o->rto_dcols,				/* -d */
+	ilog2(o->rto_dsize),			/* -s */
+	rto_opts.rto_sweep ? "yes" : "no",	/* -S */
+	o->rto_v				/* -d */
+	);
+
+	exit(requested ? 0 : 1);
+}
+
+static void process_options(int argc, char **argv)
+{
+	size_t value;
+	int opt;
+
+	raidz_test_opts_t *o = &rto_opts;
+
+	bcopy(&rto_opts_defaults, o, sizeof (*o));
+
+	while ((opt = getopt(argc, argv, "TDBSvha:o:d:s:t:")) != -1) {
+		value = 0;
+
+		switch (opt) {
+		case 'a':
+			value = strtoull(optarg, NULL, 0);
+			o->rto_ashift = MIN(13, MAX(9, value));
+			break;
+		case 'o':
+			value = strtoull(optarg, NULL, 0);
+			o->rto_offset = ((1ULL << MIN(12, value)) >> 9) << 9;
+			break;
+		case 'd':
+			value = strtoull(optarg, NULL, 0);
+			o->rto_dcols = MIN(255, MAX(1, value));
+			break;
+		case 's':
+			value = strtoull(optarg, NULL, 0);
+			o->rto_dsize = 1ULL <<  MIN(SPA_MAXBLOCKSHIFT,
+			    MAX(SPA_MINBLOCKSHIFT, value));
+			break;
+		case 't':
+			value = strtoull(optarg, NULL, 0);
+			o->rto_sweep_timeout = value;
+			break;
+		case 'v':
+			o->rto_v++;
+			break;
+		case 'S':
+			o->rto_sweep = 1;
+			break;
+		case 'B':
+			o->rto_benchmark = 1;
+			break;
+		case 'D':
+			o->rto_gdb = 1;
+			break;
+		case 'T':
+			o->rto_sanity = 1;
+			break;
+		case 'h':
+			usage(B_TRUE);
+			break;
+		case '?':
+		default:
+			usage(B_FALSE);
+			break;
+		}
+	}
+}
+
+#define	DATA_COL(rm, i) ((rm)->rm_col[raidz_parity(rm) + (i)].rc_data)
+#define	DATA_COL_SIZE(rm, i) ((rm)->rm_col[raidz_parity(rm) + (i)].rc_size)
+
+#define	CODE_COL(rm, i) ((rm)->rm_col[(i)].rc_data)
+#define	CODE_COL_SIZE(rm, i) ((rm)->rm_col[(i)].rc_size)
+
+static int
+cmp_code(raidz_test_opts_t *opts, const raidz_map_t *rm, const int parity)
+{
+	int i, ret = 0;
+
+	VERIFY(parity >= 1 && parity <= 3);
+
+	for (i = 0; i < parity; i++) {
+		if (0 != memcmp(CODE_COL(rm, i), CODE_COL(opts->rm_golden, i),
+			CODE_COL_SIZE(rm, i))) {
+			ret++;
+
+			LOG_OPT(D_DEBUG, opts,
+			    "\nParity block [%d] different!\n", i);
+		}
+	}
+	return (ret);
+}
+
+static int
+cmp_data(raidz_test_opts_t *opts, raidz_map_t *rm)
+{
+	int i, ret = 0;
+	int dcols = opts->rm_golden->rm_cols - raidz_parity(opts->rm_golden);
+
+	for (i = 0; i < dcols; i++) {
+		if (0 != memcmp(DATA_COL(opts->rm_golden, i), DATA_COL(rm, i),
+			DATA_COL_SIZE(opts->rm_golden, i))) {
+			ret++;
+
+			LOG_OPT(D_DEBUG, opts,
+			    "\nData block [%d] different!\n", i);
+		}
+	}
+	return (ret);
+}
+
+static void
+corrupt_colums(raidz_map_t *rm, const int *tgts, const int cnt)
+{
+	int i;
+	int *dst;
+	raidz_col_t *col;
+
+	for (i = 0; i < cnt; i++) {
+		col = &rm->rm_col[tgts[i]];
+		dst = col->rc_data;
+		for (i = 0; i < col->rc_size / sizeof (int); i++)
+			dst[i] = rand();
+	}
+}
+
+void
+init_zio_data(zio_t *zio)
+{
+	int i;
+	int *dst = (int *) zio->io_data;
+
+	for (i = 0; i < zio->io_size / sizeof (int); i++) {
+		dst[i] = rand_data[i];
+	}
+}
+
+static void
+fini_raidz_map(zio_t **zio, raidz_map_t **rm)
+{
+	vdev_raidz_map_free(*rm);
+	raidz_free((*zio)->io_data, (*zio)->io_size);
+	umem_free(*zio, sizeof (zio_t));
+
+	*zio = NULL;
+	*rm = NULL;
+}
+
+static int
+init_raidz_golden_map(raidz_test_opts_t *opts, const int parity)
+{
+	int err = 0;
+	zio_t *zio_test;
+	raidz_map_t *rm_test;
+	const size_t total_ncols = opts->rto_dcols + parity;
+
+	if (opts->rm_golden) {
+		fini_raidz_map(&opts->zio_golden, &opts->rm_golden);
+	}
+
+	opts->zio_golden = umem_zalloc(sizeof (zio_t), UMEM_NOFAIL);
+	zio_test = umem_zalloc(sizeof (zio_t), UMEM_NOFAIL);
+
+	opts->zio_golden->io_offset = zio_test->io_offset = opts->rto_offset;
+	opts->zio_golden->io_size = zio_test->io_size = opts->rto_dsize;
+
+	opts->zio_golden->io_data = raidz_alloc(opts->rto_dsize);
+	zio_test->io_data = raidz_alloc(opts->rto_dsize);
+
+	init_zio_data(opts->zio_golden);
+	init_zio_data(zio_test);
+
+	VERIFY0(vdev_raidz_impl_set("original"));
+
+	opts->rm_golden = vdev_raidz_map_alloc(opts->zio_golden,
+	    opts->rto_ashift, total_ncols, parity);
+	rm_test = vdev_raidz_map_alloc(zio_test,
+	    opts->rto_ashift, total_ncols, parity);
+
+	VERIFY(opts->zio_golden);
+	VERIFY(opts->rm_golden);
+
+	vdev_raidz_generate_parity(opts->rm_golden);
+	vdev_raidz_generate_parity(rm_test);
+
+	/* sanity check */
+	err |= cmp_data(opts, rm_test);
+	err |= cmp_code(opts, rm_test, parity);
+
+	if (err)
+		ERR("initializing the golden copy ... [FAIL]!\n");
+
+	/* tear down raidz_map of test zio */
+	fini_raidz_map(&zio_test, &rm_test);
+
+	return (err);
+}
+
+static raidz_map_t *
+init_raidz_map(raidz_test_opts_t *opts, zio_t **zio, const int parity)
+{
+	raidz_map_t *rm = NULL;
+	const size_t alloc_dsize = opts->rto_dsize;
+	const size_t total_ncols = opts->rto_dcols + parity;
+	const int ccols[] = { 0, 1, 2 };
+
+	VERIFY(zio);
+	VERIFY(parity <= 3 && parity >= 1);
+
+	*zio = umem_zalloc(sizeof (zio_t), UMEM_NOFAIL);
+
+	(*zio)->io_offset = 0;
+	(*zio)->io_size = alloc_dsize;
+	(*zio)->io_data = raidz_alloc(alloc_dsize);
+	init_zio_data(*zio);
+
+	rm = vdev_raidz_map_alloc(*zio, opts->rto_ashift,
+		total_ncols, parity);
+	VERIFY(rm);
+
+	/* Make sure code columns are destroyed */
+	corrupt_colums(rm, ccols, parity);
+
+	return (rm);
+}
+
+static int
+run_gen_check(raidz_test_opts_t *opts)
+{
+	char **impl_name;
+	int fn, err = 0;
+	zio_t *zio_test;
+	raidz_map_t *rm_test;
+
+	err = init_raidz_golden_map(opts, PARITY_PQR);
+	if (0 != err)
+		return (err);
+
+	LOG(D_INFO, DBLSEP);
+	LOG(D_INFO, "Testing parity generation...\n");
+
+	for (impl_name = (char **)raidz_impl_names+1; *impl_name != NULL;
+	    impl_name++) {
+
+		LOG(D_INFO, SEP);
+		LOG(D_INFO, "\tTesting [%s] implementation...", *impl_name);
+
+		if (0 != vdev_raidz_impl_set(*impl_name)) {
+			LOG(D_INFO, "[SKIP]\n");
+			continue;
+		} else {
+			LOG(D_INFO, "[SUPPORTED]\n");
+		}
+
+		for (fn = 0; fn < RAIDZ_GEN_NUM; fn++) {
+
+			/* create suitable raidz_map */
+			rm_test = init_raidz_map(opts, &zio_test, fn+1);
+			VERIFY(rm_test);
+
+			LOG(D_INFO, "\t\tTesting method [%s] ...",
+			    raidz_gen_name[fn]);
+
+			if (!opts->rto_sanity)
+				vdev_raidz_generate_parity(rm_test);
+
+			if (cmp_code(opts, rm_test, fn+1) != 0) {
+				LOG(D_INFO, "[FAIL]\n");
+				err++;
+			} else
+				LOG(D_INFO, "[PASS]\n");
+
+			fini_raidz_map(&zio_test, &rm_test);
+		}
+	}
+
+	fini_raidz_map(&opts->zio_golden, &opts->rm_golden);
+
+	return (err);
+}
+
+static int
+run_rec_check_impl(raidz_test_opts_t *opts, raidz_map_t *rm, const int fn)
+{
+	int x0, x1, x2;
+	int tgtidx[3];
+	int err = 0;
+	static const int rec_tgts[7][3] = {
+		{1, 2, 3},	/* rec_p:   bad QR & D[0]	*/
+		{0, 2, 3},	/* rec_q:   bad PR & D[0]	*/
+		{0, 1, 3},	/* rec_r:   bad PQ & D[0]	*/
+		{2, 3, 4},	/* rec_pq:  bad R  & D[0][1]	*/
+		{1, 3, 4},	/* rec_pr:  bad Q  & D[0][1]	*/
+		{0, 3, 4},	/* rec_qr:  bad P  & D[0][1]	*/
+		{3, 4, 5}	/* rec_pqr: bad    & D[0][1][2] */
+	};
+
+	memcpy(tgtidx, rec_tgts[fn], sizeof (tgtidx));
+
+	if (fn < RAIDZ_REC_PQ) {
+		/* can reconstruct 1 failed data disk */
+		for (x0 = 0; x0 < opts->rto_dcols; x0++) {
+			if (x0 >= rm->rm_cols - raidz_parity(rm))
+				continue;
+
+			LOG(D_DEBUG, "[%d] ", x0);
+
+			tgtidx[2] = x0 + raidz_parity(rm);
+
+			corrupt_colums(rm, tgtidx+2, 1);
+
+			if (!opts->rto_sanity)
+				vdev_raidz_reconstruct(rm, tgtidx, 3);
+
+			if (cmp_data(opts, rm) != 0) {
+				err++;
+				LOG(D_DEBUG, "\nREC D[%d]... [FAIL]\n", x0);
+			}
+		}
+
+	} else if (fn < RAIDZ_REC_PQR) {
+		/* can reconstruct 2 failed data disk */
+		for (x0 = 0; x0 < opts->rto_dcols; x0++) {
+			if (x0 >= rm->rm_cols - raidz_parity(rm))
+				continue;
+			for (x1 = x0 + 1; x1 < opts->rto_dcols; x1++) {
+				if (x1 >= rm->rm_cols - raidz_parity(rm))
+					continue;
+
+				LOG(D_DEBUG, "[%d %d] ", x0, x1);
+
+				tgtidx[1] = x0 + raidz_parity(rm);
+				tgtidx[2] = x1 + raidz_parity(rm);
+
+				corrupt_colums(rm, tgtidx+1, 2);
+
+				if (!opts->rto_sanity)
+					vdev_raidz_reconstruct(rm, tgtidx, 3);
+
+				if (cmp_data(opts, rm) != 0) {
+					err++;
+					LOG(D_DEBUG, "\nREC D[%d %d]... "
+					    "[FAIL]\n", x0, x1);
+				}
+			}
+		}
+	} else {
+		/* can reconstruct 3 failed data disk */
+		for (x0 = 0;
+			x0 < opts->rto_dcols; x0++) {
+			if (x0 >= rm->rm_cols - raidz_parity(rm))
+				continue;
+			for (x1 = x0 + 1;
+				x1 < opts->rto_dcols; x1++) {
+				if (x1 >= rm->rm_cols - raidz_parity(rm))
+					continue;
+				for (x2 = x1 + 1;
+					x2 < opts->rto_dcols; x2++) {
+					if (x2 >=
+						rm->rm_cols - raidz_parity(rm))
+						continue;
+
+					LOG(D_DEBUG, "[%d %d %d]", x0, x1, x2);
+
+					tgtidx[0] = x0 + raidz_parity(rm);
+					tgtidx[1] = x1 + raidz_parity(rm);
+					tgtidx[2] = x2 + raidz_parity(rm);
+
+					corrupt_colums(rm, tgtidx, 3);
+
+					if (!opts->rto_sanity)
+						vdev_raidz_reconstruct(rm,
+							tgtidx, 3);
+
+					if (cmp_data(opts, rm) != 0) {
+						err++;
+						LOG(D_DEBUG,
+						    "\nREC D[%d %d %d]... "
+						    "[FAIL]\n", x0, x1, x2);
+					}
+				}
+			}
+		}
+	}
+	return (err);
+}
+
+static int
+run_rec_check(raidz_test_opts_t *opts)
+{
+	char **impl_name;
+	unsigned fn, err = 0;
+	zio_t *zio_test;
+	raidz_map_t *rm_test;
+
+	err = init_raidz_golden_map(opts, PARITY_PQR);
+	if (0 != err)
+		return (err);
+
+	LOG(D_INFO, DBLSEP);
+	LOG(D_INFO, "Testing data reconstruction...\n");
+
+	for (impl_name = (char **)raidz_impl_names+1; *impl_name != NULL;
+	    impl_name++) {
+
+		LOG(D_INFO, SEP);
+		LOG(D_INFO, "\tTesting [%s] implementation...", *impl_name);
+
+		if (vdev_raidz_impl_set(*impl_name) != 0) {
+			LOG(D_INFO, "[SKIP]\n");
+			continue;
+		} else
+			LOG(D_INFO, "[SUPPORTED]\n");
+
+
+		/* create suitable raidz_map */
+		rm_test = init_raidz_map(opts, &zio_test, PARITY_PQR);
+		/* generate parity */
+		vdev_raidz_generate_parity(rm_test);
+
+		for (fn = 0; fn < RAIDZ_REC_NUM; fn++) {
+
+			LOG(D_INFO, "\t\tTesting method [%s] ...",
+				raidz_rec_name[fn]);
+
+			if (run_rec_check_impl(opts, rm_test, fn) != 0) {
+				LOG(D_INFO, "[FAIL]\n");
+				err++;
+
+			} else
+				LOG(D_INFO, "[PASS]\n");
+
+		}
+		/* tear down test raidz_map */
+		fini_raidz_map(&zio_test, &rm_test);
+	}
+
+	fini_raidz_map(&opts->zio_golden, &opts->rm_golden);
+
+	return (err);
+}
+
+static int
+run_test(raidz_test_opts_t *opts)
+{
+	int err = 0;
+
+	if (opts == NULL)
+		opts = &rto_opts;
+
+	print_opts(opts, B_FALSE);
+
+	err |= run_gen_check(opts);
+	err |= run_rec_check(opts);
+
+	return (err);
+}
+
+#define	SWEEP_RUNNING	0
+#define	SWEEP_FINISHED	1
+#define	SWEEP_ERROR	2
+#define	SWEEP_TIMEOUT	3
+
+static int sweep_state = 0;
+static raidz_test_opts_t failed_opts;
+
+static kmutex_t sem_mtx;
+static kcondvar_t sem_cv;
+static int max_free_slots;
+static int free_slots;
+
+static void
+sweep_thread(void *arg)
+{
+	int err = 0;
+	raidz_test_opts_t *opts = (raidz_test_opts_t *) arg;
+	VERIFY(opts != NULL);
+
+	err = run_test(opts);
+
+	if (rto_opts.rto_sanity) {
+		/* 25% chance that a sweep test fails */
+		if (rand() < (RAND_MAX/4))
+			err = 1;
+	}
+
+	if (0 != err) {
+		mutex_enter(&sem_mtx);
+		memcpy(&failed_opts, opts, sizeof (raidz_test_opts_t));
+		sweep_state = SWEEP_ERROR;
+		mutex_exit(&sem_mtx);
+	}
+
+	umem_free(opts, sizeof (raidz_test_opts_t));
+
+	/* signal the next thread */
+	mutex_enter(&sem_mtx);
+	free_slots++;
+	cv_signal(&sem_cv);
+	mutex_exit(&sem_mtx);
+
+	thread_exit();
+}
+
+static int
+run_sweep(void)
+{
+	static const size_t dcols_v[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+	static const size_t ashift_v[] = { 9, 12 };
+	static const size_t offset_cnt = 4;
+	static const size_t size_v[] = { 1 << 9, 21 * (1 << 9), 13 * (1 << 12),
+		1 << 17, (1 << 20) - (1 << 12), SPA_MAXBLOCKSIZE };
+
+	(void) setvbuf(stdout, NULL, _IONBF, 0);
+
+	ulong_t total_comb = ARRAY_SIZE(size_v) * ARRAY_SIZE(ashift_v) *
+	    ARRAY_SIZE(dcols_v) * offset_cnt;
+	ulong_t tried_comb = 0;
+	hrtime_t time_diff, start_time = gethrtime();
+	raidz_test_opts_t *opts;
+	int a, d, o, s;
+
+	max_free_slots = free_slots = MAX(2, boot_ncpus);
+
+	mutex_init(&sem_mtx, NULL, MUTEX_DEFAULT, NULL);
+	cv_init(&sem_cv, NULL, CV_DEFAULT, NULL);
+
+	for (s = 0; s < ARRAY_SIZE(size_v); s++)
+	for (a = 0; a < ARRAY_SIZE(ashift_v); a++)
+	for (o = 0; o < offset_cnt; o++)
+	for (d = 0; d < ARRAY_SIZE(dcols_v); d++) {
+
+		if ((size_v[s] < (1 << ashift_v[a]) * o) ||
+		    (size_v[s] < (1 << ashift_v[a]) * dcols_v[d])) {
+			total_comb--;
+			continue;
+		}
+
+		if (++tried_comb % 20 == 0)
+			LOG(D_ALL, "%lu/%lu... ", tried_comb, total_comb);
+
+		/* wait for signal to start new thread */
+		mutex_enter(&sem_mtx);
+		while (cv_timedwait_sig(&sem_cv, &sem_mtx,
+		    ddi_get_lbolt() + hz)) {
+
+			/* check if should stop the test (timeout) */
+			time_diff = (gethrtime() - start_time) / NANOSEC;
+			if (rto_opts.rto_sweep_timeout > 0 &&
+			    time_diff >= rto_opts.rto_sweep_timeout) {
+				sweep_state = SWEEP_TIMEOUT;
+				mutex_exit(&sem_mtx);
+				goto exit;
+			}
+
+			/* check if should stop the test (error) */
+			if (sweep_state != SWEEP_RUNNING) {
+				mutex_exit(&sem_mtx);
+				goto exit;
+			}
+
+			/* exit loop if a slot is available */
+			if (free_slots > 0) {
+				break;
+			}
+		}
+
+		free_slots--;
+		mutex_exit(&sem_mtx);
+
+		opts = umem_zalloc(sizeof (raidz_test_opts_t), UMEM_NOFAIL);
+		opts->rto_ashift = ashift_v[a];
+		opts->rto_dcols = dcols_v[d];
+		opts->rto_offset = (1 << ashift_v[a]) * o;
+		opts->rto_dsize = size_v[s];
+		opts->rto_v = 0; /* be quiet */
+
+		VERIFY3P(zk_thread_create(NULL, 0,
+		    (thread_func_t) sweep_thread,
+		    (void *) opts, TS_RUN, NULL, 0, 0,
+		    PTHREAD_CREATE_JOINABLE), !=, NULL);
+	}
+
+exit:
+	LOG(D_ALL, "\nWaiting for test threads to finish...\n");
+	mutex_enter(&sem_mtx);
+	VERIFY(free_slots <= max_free_slots);
+	while (free_slots < max_free_slots) {
+		(void) cv_wait(&sem_cv, &sem_mtx);
+	}
+	mutex_exit(&sem_mtx);
+
+	if (sweep_state == SWEEP_ERROR) {
+		ERR("Sweep test failed! Failed option: \n");
+		print_opts(&failed_opts, B_TRUE);
+	} else {
+		if (sweep_state == SWEEP_TIMEOUT)
+			LOG(D_ALL, "Test timeout (%lus). Stopping...\n",
+			    (ulong_t)rto_opts.rto_sweep_timeout);
+
+		LOG(D_ALL, "Sweep test succeeded on %lu raidz maps!\n",
+		    (ulong_t)tried_comb);
+	}
+
+	return (sweep_state == SWEEP_ERROR ? SWEEP_ERROR : 0);
+}
+
+int
+main(int argc, char **argv)
+{
+	size_t i;
+	struct sigaction action;
+	int err = 0;
+
+	/* init gdb string early */
+	(void) sprintf(gdb, gdb_tmpl, getpid());
+
+	action.sa_handler = sig_handler;
+	sigemptyset(&action.sa_mask);
+	action.sa_flags = 0;
+
+	if (sigaction(SIGSEGV, &action, NULL) < 0) {
+		ERR("raidz_test: cannot catch SIGSEGV: %s.\n", strerror(errno));
+		exit(EXIT_FAILURE);
+	}
+
+	(void) setvbuf(stdout, NULL, _IOLBF, 0);
+
+	dprintf_setup(&argc, argv);
+
+	process_options(argc, argv);
+
+	kernel_init(FREAD);
+
+	/* setup random data because rand() is not reentrant */
+	rand_data = (int *) umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
+	srand((unsigned)time(NULL) * getpid());
+	for (i = 0; i < SPA_MAXBLOCKSIZE / sizeof (int); i++)
+		rand_data[i] = rand();
+
+	mprotect(rand_data, SPA_MAXBLOCKSIZE, PROT_READ);
+
+	if (rto_opts.rto_benchmark) {
+		run_raidz_benchmark();
+	} else if (rto_opts.rto_sweep) {
+		err = run_sweep();
+	} else {
+		err = run_test(NULL);
+	}
+
+	umem_free(rand_data, SPA_MAXBLOCKSIZE);
+	kernel_fini();
+
+	return (err);
+}
diff --git a/cmd/raidz_test/raidz_test.h b/cmd/raidz_test/raidz_test.h
new file mode 100644
index 000000000..8eccc43ca
--- /dev/null
+++ b/cmd/raidz_test/raidz_test.h
@@ -0,0 +1,106 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright (C) 2016 Gvozden Nešković. All rights reserved.
+ */
+
+#ifndef	RAIDZ_TEST_H
+#define	RAIDZ_TEST_H
+
+#include <sys/spa.h>
+
+static const char *raidz_impl_names[] = {
+	"original",
+	"scalar",
+	"sse",
+	"avx2",
+	NULL
+};
+
+typedef struct raidz_test_opts {
+	size_t rto_ashift;
+	size_t rto_offset;
+	size_t rto_dcols;
+	size_t rto_dsize;
+	size_t rto_v;
+	size_t rto_sweep;
+	size_t rto_sweep_timeout;
+	size_t rto_benchmark;
+	size_t rto_sanity;
+	size_t rto_gdb;
+
+	zio_t *zio_golden;
+	raidz_map_t *rm_golden;
+} raidz_test_opts_t;
+
+static const raidz_test_opts_t rto_opts_defaults = {
+	.rto_ashift = 9,
+	.rto_offset = 1ULL << 0,
+	.rto_dcols = 8,
+	.rto_dsize = 1<<19,
+	.rto_v = 0,
+	.rto_sweep = 0,
+	.rto_benchmark = 0,
+	.rto_sanity = 0,
+	.rto_gdb = 0
+};
+
+extern raidz_test_opts_t rto_opts;
+
+static inline size_t ilog2(size_t a)
+{
+	return (a > 1 ? 1 + ilog2(a >> 1) : 0);
+}
+
+
+#define	D_ALL	0
+#define	D_INFO	1
+#define	D_DEBUG	2
+
+#define	LOG(lvl, a...)				\
+{						\
+	if (rto_opts.rto_v >= lvl)		\
+		(void) fprintf(stdout, a);	\
+}						\
+
+#define	LOG_OPT(lvl, opt, a...)			\
+{						\
+	if (opt->rto_v >= lvl)			\
+		(void) fprintf(stdout, a);	\
+}						\
+
+#define	ERR(a...)	(void) fprintf(stderr, a)
+
+
+#define	DBLSEP "================\n"
+#define	SEP    "----------------\n"
+
+
+#define	raidz_alloc(size)	zio_data_buf_alloc(size)
+#define	raidz_free(p, size)	zio_data_buf_free(p, size)
+
+
+void init_zio_data(zio_t *zio);
+
+void run_raidz_benchmark(void);
+
+#endif /* RAIDZ_TEST_H */