From 3be88162b9aa93b2dbc823d273e8b356165d47e6 Mon Sep 17 00:00:00 2001 From: Andrea Mazzoleni Date: Wed, 1 Jan 2014 20:38:19 +0100 Subject: [PATCH] Rafactors again with some minor changes. --- raid/memory.h | 22 +++++++++++---------- raid/module.c | 54 +++++++++++++++++++++++++++++---------------------- raid/test.c | 16 +++++++++++---- 3 files changed, 55 insertions(+), 37 deletions(-) diff --git a/raid/memory.h b/raid/memory.h index 192fcca6..3a679709 100644 --- a/raid/memory.h +++ b/raid/memory.h @@ -24,7 +24,7 @@ /** * Memory displacement to avoid cache collisions on contiguous blocks, - * ued by raid_malloc_vector(). + * used by raid_malloc_vector(). * * When allocating a sequence of blocks with a size of power of 2, * there is the risk that the start of each block is mapped into the same @@ -32,20 +32,22 @@ * in parallel, from the start to the end. * * The selected value was choosen empirically with some speed tests - * with 8/12/16/20/24 data buffers and 3 parity buffers - * for RAID-5/6/TP computation. + * with 8/12/16/20/24 data buffers of 256 KB. * - * With displacement (8 buffers, icore5, 32 bit): + * With displacement: + * (8 buffers of 256 KB, icore5, 32 bits): * - * PAR1 sse2x4 21936 [MB/s] - * PAR2 sse2x2 11902 [MB/s] - * PARz sse2x1 5838 [MB/s] + * sse2 + * par1 21936 [MB/s] + * par2 11902 [MB/s] + * parz 5838 [MB/s] * * Without displacement: * - * PAR1 sse2x4 15368 [MB/s] - * PAR2 sse2x2 6814 [MB/s] - * PARz sse2x1 3033 [MB/s] + * sse2 + * par1 15368 [MB/s] + * par2 6814 [MB/s] + * parz 3033 [MB/s] */ #define RAID_MALLOC_DISPLACEMENT (7*256) diff --git a/raid/module.c b/raid/module.c index 25b709c6..abd52cb8 100644 --- a/raid/module.c +++ b/raid/module.c @@ -16,6 +16,9 @@ #include "memory.h" #include "cpu.h" +/* + * Initializes and selects the best algorithm. + */ void raid_init(void) { raid_par3_ptr = raid_par3_int8; @@ -109,10 +112,15 @@ void raid_par_ref(int nd, int np, size_t size, void **vv) } } -/** - * Number of data disks to test. +/* + * Size of the blocks to test. */ -#define TEST_DATA_MAX 8 +#define TEST_SIZE PAGE_SIZE + +/* + * Number of data blocks to test. + */ +#define TEST_COUNT (65536 / TEST_SIZE) /* * Parity generation test. @@ -120,7 +128,7 @@ void raid_par_ref(int nd, int np, size_t size, void **vv) static int raid_test_par(int nd, int np, size_t size, void **v, void **ref) { int i; - void *t[TEST_DATA_MAX + RAID_PARITY_MAX]; + void *t[TEST_COUNT + RAID_PARITY_MAX]; /* setup data */ for (i = 0; i < nd; ++i) @@ -146,7 +154,7 @@ static int raid_test_par(int nd, int np, size_t size, void **v, void **ref) static int raid_test_rec(int nrd, int *id, int nrp, int *ip, int nd, int np, size_t size, void **v, void **ref) { int i, j; - void *t[TEST_DATA_MAX + RAID_PARITY_MAX]; + void *t[TEST_COUNT + RAID_PARITY_MAX]; /* setup data */ for (i = 0, j = 0; i < nd; ++i) { @@ -183,18 +191,19 @@ static int raid_test_rec(int nrd, int *id, int nrp, int *ip, int nd, int np, siz */ int raid_selftest(void) { - const int nd = TEST_DATA_MAX; + const int nd = TEST_COUNT; + const size_t size = TEST_SIZE; const int nv = nd + RAID_PARITY_MAX * 2 + 1; - const size_t size = 4096; void *v_alloc; void **v; void *ref[nd + RAID_PARITY_MAX]; int id[RAID_PARITY_MAX]; int ip[RAID_PARITY_MAX]; int i, np; + int ret = 0; /* ensure to have enough space for data */ - BUG_ON(TEST_DATA_MAX * size > 65536); + BUG_ON(nd * size > 65536); v = raid_malloc_vector(nd, nv, size, &v_alloc); if (!v) @@ -216,20 +225,18 @@ int raid_selftest(void) /* test for each parity level */ for (np = 1; np <= RAID_PARITY_MAX; ++np) { - int r; - /* test parity generation */ - r = raid_test_par(nd, np, size, v, ref); - if (r != 0) - return r; + ret = raid_test_par(nd, np, size, v, ref); + if (ret != 0) + return ret; /* test recovering with full broken data disks */ for (i = 0; i < np; ++i) id[i] = nd - np + i; - r = raid_test_rec(np, id, 0, ip, nd, np, size, v, ref); - if (r != 0) - return r; + ret = raid_test_rec(np, id, 0, ip, nd, np, size, v, ref); + if (ret != 0) + goto bail; /* test recovering with half broken data and ending parity */ for (i = 0; i < np / 2; ++i) @@ -238,9 +245,9 @@ int raid_selftest(void) for (i = 0; i < (np + 1) / 2; ++i) ip[i] = np - np / 2 + i; - r = raid_test_rec(np / 2, id, np / 2, ip, nd, np, size, v, ref); - if (r != 0) - return r; + ret = raid_test_rec(np / 2, id, np / 2, ip, nd, np, size, v, ref); + if (ret != 0) + goto bail; /* test recovering with half broken data and leading parity */ for (i = 0; i < np / 2; ++i) @@ -249,14 +256,15 @@ int raid_selftest(void) for (i = 0; i < (np + 1) / 2; ++i) ip[i] = i; - r = raid_test_rec(np / 2, id, np / 2, ip, nd, np, size, v, ref); - if (r != 0) - return r; + ret = raid_test_rec(np / 2, id, np / 2, ip, nd, np, size, v, ref); + if (ret != 0) + goto bail; } +bail: free(v_alloc); - return 0; + return ret; } static struct raid_func { diff --git a/raid/test.c b/raid/test.c index 938a2f67..3eb0143f 100644 --- a/raid/test.c +++ b/raid/test.c @@ -206,7 +206,7 @@ int raid_test_rec(int mode, int nd, size_t size) /* check */ for (i = 0; i < nr; ++i) if (memcmp(test[i], data_save[i], size) != 0) - return -1; + goto bail; /* restore */ for (i = 0; i < nr; ++i) { @@ -222,8 +222,12 @@ int raid_test_rec(int mode, int nd, size_t size) free(v_alloc); free(v); - return 0; + +bail: + free(v_alloc); + free(v); + return -1; } int raid_test_par(int mode, int nd, size_t size) @@ -318,12 +322,16 @@ int raid_test_par(int mode, int nd, size_t size) /* check it */ for (i = 0; i < np; ++i) if (memcmp(v[nd + np + i], v[nd + i], size) != 0) - return -1; + goto bail; } free(v_alloc); free(v); - return 0; + +bail: + free(v_alloc); + free(v); + return -1; }