From b81e4a0141ded74506972f5a4703954bfba92d95 Mon Sep 17 00:00:00 2001
From: Andrea Mazzoleni <amadvance@gmail.com>
Date: Thu, 26 Dec 2013 09:45:51 +0100
Subject: [PATCH] Renames some variables. No functional change.

---
 check.c    |  36 ++--
 raid.c     | 488 ++++++++++++++++++++++++++---------------------------
 raid.h     |  78 ++++-----
 selftest.c |  96 +++++------
 speed.c    | 126 +++++++-------
 5 files changed, 412 insertions(+), 412 deletions(-)

diff --git a/check.c b/check.c
index a9277c0a..6a4f36a2 100644
--- a/check.c
+++ b/check.c
@@ -147,8 +147,8 @@ static int repair_step(struct snapraid_state* state, int rehash, unsigned pos, u
 	unsigned i, n;
 	int error;
 	int has_hash;
-	int d[LEV_MAX];
-	int p[LEV_MAX];
+	int id[LEV_MAX];
+	int ip[LEV_MAX];
 
 	/* no fix required */
 	if (failed_count == 0) {
@@ -167,7 +167,7 @@ static int repair_step(struct snapraid_state* state, int rehash, unsigned pos, u
 
 	/* setup vector of failed disk indexes */
 	for(i=0;i<failed_count;++i)
-		d[i] = failed[failed_map[i]].index;
+		id[i] = failed[failed_map[i]].index;
 
 	/* check if there is at least a failed block that can be checked for correctness using the hash */
 	/* if there isn't, we have to sacrifice a parity block to check that the result is correct */
@@ -184,11 +184,11 @@ static int repair_step(struct snapraid_state* state, int rehash, unsigned pos, u
 		unsigned r = failed_count + 1;
 
 		/* all combinations (r of n) parities */
-		combination_first(r, n, p);
+		combination_first(r, n, ip);
 		do {
 			/* if a parity is missing, do nothing */
 			for(i=0;i<r;++i) {
-				if (buffer_recov[p[i]] == 0)
+				if (buffer_recov[ip[i]] == 0)
 					break;
 			}
 			if (i != r)
@@ -196,13 +196,13 @@ static int repair_step(struct snapraid_state* state, int rehash, unsigned pos, u
 
 			/* copy the parities to use, one less because the last is used for checking */
 			for(i=0;i<r-1;++i)
-				memcpy(buffer[diskmax+p[i]], buffer_recov[p[i]], state->block_size);
+				memcpy(buffer[diskmax+ip[i]], buffer_recov[ip[i]], state->block_size);
 
-			/* recover using one less parity, the p[r-1] one */
-			raid_rec(r-1, d, p, diskmax, state->block_size, buffer, buffer_zero);
+			/* recover using one less parity, the ip[r-1] one */
+			raid_rec(r-1, id, ip, diskmax, state->block_size, buffer, buffer_zero);
 
-			/* use the remaining p[r-1] parity to check the result */
-			if (is_parity_matching(state, diskmax, p[r-1], buffer, buffer_recov))
+			/* use the remaining ip[r-1] parity to check the result */
+			if (is_parity_matching(state, diskmax, ip[r-1], buffer, buffer_recov))
 				return 0;
 
 			/* log */
@@ -210,11 +210,11 @@ static int repair_step(struct snapraid_state* state, int rehash, unsigned pos, u
 			for(i=0;i<r;++i) {
 				if (i != 0)
 					fprintf(stdlog, "/");
-				fprintf(stdlog, "%s", lev_config_name(p[i]));
+				fprintf(stdlog, "%s", lev_config_name(ip[i]));
 			}
 			fprintf(stdlog, ": Data error\n");
 			++error;
-		} while (combination_next(r, n, p));
+		} while (combination_next(r, n, ip));
 	}
 
 	/* if we have a hash, and enough parities */
@@ -224,11 +224,11 @@ static int repair_step(struct snapraid_state* state, int rehash, unsigned pos, u
 		unsigned r = failed_count;
 
 		/* all combinations (r of n) parities */
-		combination_first(r, n, p);
+		combination_first(r, n, ip);
 		do {
 			/* if a parity is missing, do nothing */
 			for(i=0;i<r;++i) {
-				if (buffer_recov[p[i]] == 0)
+				if (buffer_recov[ip[i]] == 0)
 					break;
 			}
 			if (i != r)
@@ -236,10 +236,10 @@ static int repair_step(struct snapraid_state* state, int rehash, unsigned pos, u
 
 			/* copy the parities to use */
 			for(i=0;i<r;++i)
-				memcpy(buffer[diskmax+p[i]], buffer_recov[p[i]], state->block_size);
+				memcpy(buffer[diskmax+ip[i]], buffer_recov[ip[i]], state->block_size);
 
 			/* recover */
-			raid_rec(r, d, p, diskmax, state->block_size, buffer, buffer_zero);
+			raid_rec(r, id, ip, diskmax, state->block_size, buffer, buffer_zero);
 
 			/* use the hash to check the result */
 			if (is_hash_matching(state, rehash, diskmax, failed, failed_map, failed_count, buffer, buffer_zero))
@@ -250,11 +250,11 @@ static int repair_step(struct snapraid_state* state, int rehash, unsigned pos, u
 			for(i=0;i<r;++i) {
 				if (i != 0)
 					fprintf(stdlog, "/");
-				fprintf(stdlog, "%s", lev_config_name(p[i]));
+				fprintf(stdlog, "%s", lev_config_name(ip[i]));
 			}
 			fprintf(stdlog, ": Data error\n");
 			++error;
-		} while (combination_next(r, n, p));
+		} while (combination_next(r, n, ip));
 	}
 
 	/* return the number of failed attempts, or -1 if no strategy */
diff --git a/raid.c b/raid.c
index 14b876b5..0811a774 100644
--- a/raid.c
+++ b/raid.c
@@ -217,7 +217,7 @@
 /*
  * PAR1 (RAID5 with xor) 32bit C implementation
  */
-void raid_par1_int32(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par1_int32(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	int d, l;
@@ -226,8 +226,8 @@ void raid_par1_int32(unsigned ndata, unsigned size, unsigned char** vbuf)
 	uint32_t p0;
 	uint32_t p1;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
+	l = nd - 1;
+	p = vbuf[nd];
 
 	for(i=0;i<size;i+=8) {
 		p0 = v_32(vbuf[l][i]);
@@ -246,7 +246,7 @@ void raid_par1_int32(unsigned ndata, unsigned size, unsigned char** vbuf)
 /*
  * PAR1 (RAID5 with xor) 64bit C implementation
  */
-void raid_par1_int64(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par1_int64(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	int d, l;
@@ -255,8 +255,8 @@ void raid_par1_int64(unsigned ndata, unsigned size, unsigned char** vbuf)
 	uint64_t p0;
 	uint64_t p1;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
+	l = nd - 1;
+	p = vbuf[nd];
 
 	for(i=0;i<size;i+=16) {
 		p0 = v_64(vbuf[l][i]);
@@ -281,14 +281,14 @@ void raid_par1_int64(unsigned ndata, unsigned size, unsigned char** vbuf)
  * the typical cache block, and processing 128 bytes doesn't increase
  * performance.
  */
-void raid_par1_sse2(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par1_sse2(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	int d, l;
 	unsigned i;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
+	l = nd - 1;
+	p = vbuf[nd];
 
 	for(i=0;i<size;i+=64) {
 		asm volatile("movdqa %0,%%xmm0" : : "m" (vbuf[l][i]));
@@ -372,7 +372,7 @@ static inline uint64_t d2_64(uint64_t v)
 /*
  * PAR2 (RAID6 with powers of 2) 32bit C implementation
  */
-void raid_par2_int32(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par2_int32(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -382,9 +382,9 @@ void raid_par2_int32(unsigned ndata, unsigned size, unsigned char** vbuf)
 	uint32_t d0, q0, p0;
 	uint32_t d1, q1, p1;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
 
 	for(i=0;i<size;i+=8) {
 		q0 = p0 = v_32(vbuf[l][i]);
@@ -412,7 +412,7 @@ void raid_par2_int32(unsigned ndata, unsigned size, unsigned char** vbuf)
 /*
  * PAR2 (RAID6 with powers of 2) 64bit C implementation
  */
-void raid_par2_int64(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par2_int64(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -422,9 +422,9 @@ void raid_par2_int64(unsigned ndata, unsigned size, unsigned char** vbuf)
 	uint64_t d0, q0, p0;
 	uint64_t d1, q1, p1;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
 
 	for(i=0;i<size;i+=16) {
 		q0 = p0 = v_64(vbuf[l][i]);
@@ -465,16 +465,16 @@ static const struct gfconst16 {
 /*
  * PAR2 (RAID6 with powers of 2) SSE2 implementation
  */
-void raid_par2_sse2(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par2_sse2(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
 	int d, l;
 	unsigned i;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
 
 	asm volatile("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
 
@@ -518,16 +518,16 @@ void raid_par2_sse2(unsigned ndata, unsigned size, unsigned char** vbuf)
  *
  * Note that it uses 16 registers, meaning that x64 is required.
  */
-void raid_par2_sse2ext(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par2_sse2ext(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
 	int d, l;
 	unsigned i;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
 
 	asm volatile("movdqa %0,%%xmm15" : : "m" (gfconst16.poly[0]));
 
@@ -592,7 +592,7 @@ void raid_par2_sse2ext(unsigned ndata, unsigned size, unsigned char** vbuf)
 /*
  * PARz (triple parity with powers of 2^-1) 32bit C implementation
  */
-void raid_parz_int32(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_parz_int32(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -603,10 +603,10 @@ void raid_parz_int32(unsigned ndata, unsigned size, unsigned char** vbuf)
 	uint32_t d0, r0, q0, p0;
 	uint32_t d1, r1, q1, p1;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
 
 	for(i=0;i<size;i+=8) {
 		r0 = q0 = p0 = v_32(vbuf[l][i]);
@@ -642,7 +642,7 @@ void raid_parz_int32(unsigned ndata, unsigned size, unsigned char** vbuf)
 /*
  * PARz (triple parity with powers of 2^-1) 64bit C implementation
  */
-void raid_parz_int64(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_parz_int64(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -653,10 +653,10 @@ void raid_parz_int64(unsigned ndata, unsigned size, unsigned char** vbuf)
 	uint64_t d0, r0, q0, p0;
 	uint64_t d1, r1, q1, p1;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
 
 	for(i=0;i<size;i+=16) {
 		r0 = q0 = p0 = v_64(vbuf[l][i]);
@@ -693,7 +693,7 @@ void raid_parz_int64(unsigned ndata, unsigned size, unsigned char** vbuf)
 /*
  * PARz (triple parity with powers of 2^-1) SSE2 implementation
  */
-void raid_parz_sse2(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_parz_sse2(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -701,10 +701,10 @@ void raid_parz_sse2(unsigned ndata, unsigned size, unsigned char** vbuf)
 	int d, l;
 	unsigned i;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
 
 	asm volatile("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
 	asm volatile("movdqa %0,%%xmm3" : : "m" (gfconst16.half[0]));
@@ -750,7 +750,7 @@ void raid_parz_sse2(unsigned ndata, unsigned size, unsigned char** vbuf)
  *
  * Note that it uses 16 registers, meaning that x64 is required.
  */
-void raid_parz_sse2ext(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_parz_sse2ext(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -758,10 +758,10 @@ void raid_parz_sse2ext(unsigned ndata, unsigned size, unsigned char** vbuf)
 	int d, l;
 	unsigned i;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
 
 	asm volatile("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
 	asm volatile("movdqa %0,%%xmm3" : : "m" (gfconst16.half[0]));
@@ -831,7 +831,7 @@ void raid_parz_sse2ext(unsigned ndata, unsigned size, unsigned char** vbuf)
  * But this is only a kind of reference function, and we are not really
  * interested in speed.
  */
-void raid_par3_int8(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par3_int8(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -841,10 +841,10 @@ void raid_par3_int8(unsigned ndata, unsigned size, unsigned char** vbuf)
 
 	uint8_t d0, r0, q0, p0;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
 
 	for(i=0;i<size;i+=1) {
 		p0 = q0 = r0 = 0;
@@ -873,7 +873,7 @@ void raid_par3_int8(unsigned ndata, unsigned size, unsigned char** vbuf)
 /*
  * PAR3 (triple parity with Cauchy matrix) SSSE3 implementation
  */
-void raid_par3_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par3_ssse3(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -881,10 +881,10 @@ void raid_par3_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf)
 	int d, l;
 	unsigned i;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
 
 	/* special case with only one data disk */
 	if (l == 0) {
@@ -969,7 +969,7 @@ void raid_par3_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf)
  *
  * Note that it uses 16 registers, meaning that x64 is required.
  */
-void raid_par3_ssse3ext(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par3_ssse3ext(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -977,10 +977,10 @@ void raid_par3_ssse3ext(unsigned ndata, unsigned size, unsigned char** vbuf)
 	int d, l;
 	unsigned i;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
 
 	/* special case with only one data disk */
 	if (l == 0) {
@@ -1109,7 +1109,7 @@ void raid_par3_ssse3ext(unsigned ndata, unsigned size, unsigned char** vbuf)
  * But this is only a kind of reference function, and we are not really
  * interested in speed.
  */
-void raid_par4_int8(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par4_int8(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -1120,11 +1120,11 @@ void raid_par4_int8(unsigned ndata, unsigned size, unsigned char** vbuf)
 
 	uint8_t d0, s0, r0, q0, p0;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
-	s = vbuf[ndata+3];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
+	s = vbuf[nd+3];
 
 	for(i=0;i<size;i+=1) {
 		p0 = q0 = r0 = s0 = 0;
@@ -1156,7 +1156,7 @@ void raid_par4_int8(unsigned ndata, unsigned size, unsigned char** vbuf)
 /*
  * PAR4 (quad parity with Cauchy matrix) SSSE3 implementation
  */
-void raid_par4_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par4_ssse3(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -1165,11 +1165,11 @@ void raid_par4_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf)
 	int d, l;
 	unsigned i;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
-	s = vbuf[ndata+3];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
+	s = vbuf[nd+3];
 
 	/* special case with only one data disk */
 	if (l == 0) {
@@ -1271,7 +1271,7 @@ void raid_par4_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf)
  *
  * Note that it uses 16 registers, meaning that x64 is required.
  */
-void raid_par4_ssse3ext(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par4_ssse3ext(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -1280,11 +1280,11 @@ void raid_par4_ssse3ext(unsigned ndata, unsigned size, unsigned char** vbuf)
 	int d, l;
 	unsigned i;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
-	s = vbuf[ndata+3];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
+	s = vbuf[nd+3];
 
 	/* special case with only one data disk */
 	if (l == 0) {
@@ -1443,7 +1443,7 @@ void raid_par4_ssse3ext(unsigned ndata, unsigned size, unsigned char** vbuf)
  * But this is only a kind of reference function, and we are not really
  * interested in speed.
  */
-void raid_par5_int8(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par5_int8(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -1455,12 +1455,12 @@ void raid_par5_int8(unsigned ndata, unsigned size, unsigned char** vbuf)
 
 	uint8_t d0, t0, s0, r0, q0, p0;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
-	s = vbuf[ndata+3];
-	t = vbuf[ndata+4];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
+	s = vbuf[nd+3];
+	t = vbuf[nd+4];
 
 	for(i=0;i<size;i+=1) {
 		p0 = q0 = r0 = s0 = t0 = 0;
@@ -1499,7 +1499,7 @@ void raid_par5_int8(unsigned ndata, unsigned size, unsigned char** vbuf)
 /* ensures that stack is aligned at 16 bytes because we allocate SSE registers in it */
 __attribute__((force_align_arg_pointer))
 #endif
-void raid_par5_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par5_ssse3(unsigned nd, unsigned size, unsigned char** vbuf)
 /* ensures that stack is aligned at 16 bytes because we allocate SSE registers in it */
 {
 	unsigned char* p;
@@ -1511,12 +1511,12 @@ void raid_par5_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf)
 	unsigned i;
 	unsigned char p0[16] __attribute__((aligned(16)));
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
-	s = vbuf[ndata+3];
-	t = vbuf[ndata+4];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
+	s = vbuf[nd+3];
+	t = vbuf[nd+4];
 
 	/* special case with only one data disk */
 	if (l == 0) {
@@ -1635,7 +1635,7 @@ void raid_par5_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf)
  *
  * Note that it uses 16 registers, meaning that x64 is required.
  */
-void raid_par5_ssse3ext(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par5_ssse3ext(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -1645,12 +1645,12 @@ void raid_par5_ssse3ext(unsigned ndata, unsigned size, unsigned char** vbuf)
 	int d, l;
 	unsigned i;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
-	s = vbuf[ndata+3];
-	t = vbuf[ndata+4];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
+	s = vbuf[nd+3];
+	t = vbuf[nd+4];
 
 	/* special case with only one data disk */
 	if (l == 0) {
@@ -1767,7 +1767,7 @@ void raid_par5_ssse3ext(unsigned ndata, unsigned size, unsigned char** vbuf)
  * But this is only a kind of reference function, and we are not really
  * interested in speed.
  */
-void raid_par6_int8(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par6_int8(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -1780,13 +1780,13 @@ void raid_par6_int8(unsigned ndata, unsigned size, unsigned char** vbuf)
 
 	uint8_t d0, u0, t0, s0, r0, q0, p0;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
-	s = vbuf[ndata+3];
-	t = vbuf[ndata+4];
-	u = vbuf[ndata+5];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
+	s = vbuf[nd+3];
+	t = vbuf[nd+4];
+	u = vbuf[nd+5];
 
 	for(i=0;i<size;i+=1) {
 		p0 = q0 = r0 = s0 = t0 = u0 = 0;
@@ -1828,7 +1828,7 @@ void raid_par6_int8(unsigned ndata, unsigned size, unsigned char** vbuf)
 /* ensures that stack is aligned at 16 bytes because we allocate SSE registers in it */
 __attribute__((force_align_arg_pointer))
 #endif
-void raid_par6_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par6_ssse3(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -1841,13 +1841,13 @@ void raid_par6_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf)
 	unsigned char p0[16] __attribute__((aligned(16)));
 	unsigned char q0[16] __attribute__((aligned(16))); 
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
-	s = vbuf[ndata+3];
-	t = vbuf[ndata+4];
-	u = vbuf[ndata+5];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
+	s = vbuf[nd+3];
+	t = vbuf[nd+4];
+	u = vbuf[nd+5];
 
 	/* special case with only one data disk */
 	if (l == 0) {
@@ -1985,7 +1985,7 @@ void raid_par6_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf)
  *
  * Note that it uses 16 registers, meaning that x64 is required.
  */
-void raid_par6_ssse3ext(unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par6_ssse3ext(unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* q;
@@ -1996,13 +1996,13 @@ void raid_par6_ssse3ext(unsigned ndata, unsigned size, unsigned char** vbuf)
 	int d, l;
 	unsigned i;
 
-	l = ndata - 1;
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	r = vbuf[ndata+2];
-	s = vbuf[ndata+3];
-	t = vbuf[ndata+4];
-	u = vbuf[ndata+5];
+	l = nd - 1;
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	r = vbuf[nd+2];
+	s = vbuf[nd+3];
+	t = vbuf[nd+4];
+	u = vbuf[nd+5];
 
 	/* special case with only one data disk */
 	if (l == 0) {
@@ -2140,28 +2140,28 @@ void raid_set(unsigned mode)
 /* parity generation */
 
 /* internal forwarder */
-static void (*raid_par1_ptr)(unsigned ndata, unsigned size, unsigned char** vbuf);
-static void (*raid_par2_ptr)(unsigned ndata, unsigned size, unsigned char** vbuf);
-static void (*raid_parz_ptr)(unsigned ndata, unsigned size, unsigned char** vbuf);
-static void (*raid_par3_ptr)(unsigned ndata, unsigned size, unsigned char** vbuf);
-static void (*raid_par4_ptr)(unsigned ndata, unsigned size, unsigned char** vbuf);
-static void (*raid_par5_ptr)(unsigned ndata, unsigned size, unsigned char** vbuf);
-static void (*raid_par6_ptr)(unsigned ndata, unsigned size, unsigned char** vbuf);
+static void (*raid_par1_ptr)(unsigned nd, unsigned size, unsigned char** vbuf);
+static void (*raid_par2_ptr)(unsigned nd, unsigned size, unsigned char** vbuf);
+static void (*raid_parz_ptr)(unsigned nd, unsigned size, unsigned char** vbuf);
+static void (*raid_par3_ptr)(unsigned nd, unsigned size, unsigned char** vbuf);
+static void (*raid_par4_ptr)(unsigned nd, unsigned size, unsigned char** vbuf);
+static void (*raid_par5_ptr)(unsigned nd, unsigned size, unsigned char** vbuf);
+static void (*raid_par6_ptr)(unsigned nd, unsigned size, unsigned char** vbuf);
 
-void raid_par(unsigned npar, unsigned ndata, unsigned size, unsigned char** vbuf)
+void raid_par(unsigned np, unsigned nd, unsigned size, unsigned char** vbuf)
 {
-	switch (npar) {
-	case 1 : raid_par1_ptr(ndata, size, vbuf); break;
-	case 2 : raid_par2_ptr(ndata, size, vbuf); break;
+	switch (np) {
+	case 1 : raid_par1_ptr(nd, size, vbuf); break;
+	case 2 : raid_par2_ptr(nd, size, vbuf); break;
 	case 3 :
 		if (raid_mode == RAID_MODE_CAUCHY)
-			raid_par3_ptr(ndata, size, vbuf);
+			raid_par3_ptr(nd, size, vbuf);
 		else
-			raid_parz_ptr(ndata, size, vbuf);
+			raid_parz_ptr(nd, size, vbuf);
 		break;
-	case 4 : raid_par4_ptr(ndata, size, vbuf); break;
-	case 5 : raid_par5_ptr(ndata, size, vbuf); break;
-	case 6 : raid_par6_ptr(ndata, size, vbuf); break;
+	case 4 : raid_par4_ptr(nd, size, vbuf); break;
+	case 5 : raid_par5_ptr(nd, size, vbuf); break;
+	case 6 : raid_par6_ptr(nd, size, vbuf); break;
 	default:
 		fprintf(stderr, "Invalid raid gen level\n");
 		exit(EXIT_FAILURE);
@@ -2225,40 +2225,40 @@ static inline const unsigned char* table(unsigned char v)
  * This is the parity expressed as Pa,Qa,Ra,Sa,Ta,Ua
  * in the equations.
  *
- * Note that all the other parities not in the c[] vector
+ * Note that all the other parities not in the ip[] vector
  * are destroyed.
  */
-static inline void raid_delta_gen(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero)
+static inline void raid_delta_gen(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero)
 {
 	unsigned char* p[RAID_PARITY_CAUCHY_MAX];
 	unsigned char* pa[RAID_PARITY_CAUCHY_MAX];
 	unsigned i;
 
-	assert(nrec > 0 && nrec <= RAID_PARITY_CAUCHY_MAX);
+	assert(nr > 0 && nr <= RAID_PARITY_CAUCHY_MAX);
 
-	for(i=0;i<nrec;++i) {
+	for(i=0;i<nr;++i) {
 		/* keep a copy of the parity buffer */
-		p[i] = vbuf[ndata+c[i]];
+		p[i] = vbuf[nd+ip[i]];
 
 		/* buffer for missing data blocks */
-		pa[i] = vbuf[d[i]];
+		pa[i] = vbuf[id[i]];
 
 		/* set at zero the missing data blocks */
-		vbuf[d[i]] = zero;
+		vbuf[id[i]] = zero;
 
 		/* compute the parity over the missing data blocks */
-		vbuf[ndata+c[i]] = pa[i];
+		vbuf[nd+ip[i]] = pa[i];
 	}
 
-	/* compute only for the nrec we really need */
-	raid_par(c[nrec - 1] + 1, ndata, size, vbuf);
+	/* compute only for the nr we really need */
+	raid_par(ip[nr - 1] + 1, nd, size, vbuf);
 
-	for(i=0;i<nrec;++i) {
+	for(i=0;i<nr;++i) {
 		/* restore disk buffers as before */
-		vbuf[d[i]] = pa[i];
+		vbuf[id[i]] = pa[i];
 
 		/* restore parity buffers as before */
-		vbuf[ndata+c[i]] = p[i];
+		vbuf[nd+ip[i]] = p[i];
 	}
 }
 
@@ -2276,28 +2276,28 @@ static inline void raid_delta_gen(unsigned nrec, const int* d, const int* c, uns
  *
  * Dx = Pd
  */
-static void raid_rec1_par1(const int* d, unsigned ndata, unsigned size, unsigned char** vbuf)
+static void raid_rec1_par1(const int* id, unsigned nd, unsigned size, unsigned char** vbuf)
 {
 	unsigned char* p;
 	unsigned char* pa;
 
 	/* for PAR1 we can directly compute the missing block */
 	/* and we don't need to use the zero buffer */
-	p = vbuf[ndata];
-	pa = vbuf[d[0]];
+	p = vbuf[nd];
+	pa = vbuf[id[0]];
 
 	/* use the parity as missing data block */
-	vbuf[d[0]] = p;
+	vbuf[id[0]] = p;
 
 	/* compute the parity over the missing data block */
-	vbuf[ndata] = pa;
+	vbuf[nd] = pa;
 
 	/* compute */
-	raid_par1_ptr(ndata, size, vbuf);
+	raid_par1_ptr(nd, size, vbuf);
 
 	/* restore as before */
-	vbuf[d[0]] = pa;
-	vbuf[ndata] = p;
+	vbuf[id[0]] = pa;
+	vbuf[nd] = p;
 }
 
 /**
@@ -2306,24 +2306,24 @@ static void raid_rec1_par1(const int* d, unsigned ndata, unsigned size, unsigned
  * Starting from the equations:
  *
  * Pd = Dx + Dy
- * Qd = 2^d[0] * Dx + 2^d[1] * Dy
+ * Qd = 2^id[0] * Dx + 2^id[1] * Dy
  *
  * and solving we get:
  *
- *            1               2^(-d[0])
- * Dy = ----------- * Pd + ----------- * Qd
- *      2^(d[1]-d[0]) + 1        2^(d[1]-d[0]) + 1
+ *               1                     2^(-id[0])
+ * Dy = ------------------- * Pd + ------------------- * Qd
+ *      2^(id[1]-id[0]) + 1        2^(id[1]-id[0]) + 1
  *
  * Dx = Dy + Pd
  *
  * with conditions:
  *
- * 2^d[0] != 0
- * 2^(d[1]-d[0]) + 1 != 0
+ * 2^id[0] != 0
+ * 2^(id[1]-id[0]) + 1 != 0
  *
- * That are always satisfied for any 0<=d[0]<d[1]<255.
+ * That are always satisfied for any 0<=id[0]<id[1]<255.
  */
-static void raid_rec2_par2(const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero)
+static void raid_rec2_par2(const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero)
 {
 	unsigned i;
 	unsigned char* p;
@@ -2333,16 +2333,16 @@ static void raid_rec2_par2(const int* d, const int* c, unsigned ndata, unsigned
 	const unsigned char* T[2];
 
 	/* get multiplication tables */
-	T[0] = table( inv(pow2(d[1]-d[0]) ^ 1) );
-	T[1] = table( inv(pow2(d[0]) ^ pow2(d[1])) );
+	T[0] = table( inv(pow2(id[1]-id[0]) ^ 1) );
+	T[1] = table( inv(pow2(id[0]) ^ pow2(id[1])) );
 
 	/* compute delta parity */
-	raid_delta_gen(2, d, c, ndata, size, vbuf, zero);
+	raid_delta_gen(2, id, ip, nd, size, vbuf, zero);
 
-	p = vbuf[ndata];
-	q = vbuf[ndata+1];
-	pa = vbuf[d[0]];
-	qa = vbuf[d[1]];
+	p = vbuf[nd];
+	q = vbuf[nd+1];
+	pa = vbuf[id[0]];
+	qa = vbuf[id[1]];
 
 	for(i=0;i<size;++i) {
 		/* delta */
@@ -2434,17 +2434,17 @@ static inline void invert(unsigned char* M, unsigned char* V, unsigned n)
 }
 
 /**
- * Recover failure of one data block at index d[0] using parity at index c[0] for any RAID level.
+ * Recover failure of one data block at index id[0] using parity at index ip[0] for any RAID level.
  *
  * Starting from the equation:
  *
- * Pd = A[c[0],d[0]] * Dx
+ * Pd = A[ip[0],id[0]] * Dx
  *
  * and solving we get:
  *
- * Dx = A[c[0],d[0]]^-1 * Pd
+ * Dx = A[ip[0],id[0]]^-1 * Pd
  */
-void raid_rec1_int8(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero)
+void raid_rec1_int8(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero)
 {
 	unsigned i;
 	unsigned char* p;
@@ -2453,16 +2453,16 @@ void raid_rec1_int8(unsigned nrec, const int* d, const int* c, unsigned ndata, u
 	unsigned char G;
 	unsigned char V;
 
-	(void)nrec; /* unused */
+	(void)nr; /* unused */
 
 	/* if it's PAR1 uses the dedicated and fastest function */
-	if (c[0] == 0) {
-		raid_rec1_par1(d, ndata, size, vbuf);
+	if (ip[0] == 0) {
+		raid_rec1_par1(id, nd, size, vbuf);
 		return;
 	}
 
 	/* setup the coefficients matrix */
-	G = A(c[0],d[0]);
+	G = A(ip[0],id[0]);
 
 	/* invert it to solve the system of linear equations */
 	V = inv(G);
@@ -2471,10 +2471,10 @@ void raid_rec1_int8(unsigned nrec, const int* d, const int* c, unsigned ndata, u
 	T = table(V);
 
 	/* compute delta parity */
-	raid_delta_gen(1, d, c, ndata, size, vbuf, zero);
+	raid_delta_gen(1, id, ip, nd, size, vbuf, zero);
 
-	p = vbuf[ndata+c[0]];
-	pa = vbuf[d[0]];
+	p = vbuf[nd+ip[0]];
+	pa = vbuf[id[0]];
 
 	for(i=0;i<size;++i) {
 		/* delta */
@@ -2486,16 +2486,16 @@ void raid_rec1_int8(unsigned nrec, const int* d, const int* c, unsigned ndata, u
 }
 
 /**
- * Recover failure of two data blocks at indexes d[0],d[1] using parity at indexes c[0],c[1] for any RAID level.
+ * Recover failure of two data blocks at indexes id[0],id[1] using parity at indexes ip[0],ip[1] for any RAID level.
  *
  * Starting from the equations:
  *
- * Pd = A[c[0],d[0]] * Dx + A[c[0],d[1]] * Dy
- * Qd = A[c[1],d[0]] * Dx + A[c[1],d[1]] * Dy
+ * Pd = A[ip[0],id[0]] * Dx + A[ip[0],id[1]] * Dy
+ * Qd = A[ip[1],id[0]] * Dx + A[ip[1],id[1]] * Dy
  *
  * we solve inverting the coefficients matrix.
  */
-void raid_rec2_int8(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero)
+void raid_rec2_int8(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero)
 {
 	unsigned char* p;
 	unsigned char* pa;
@@ -2507,18 +2507,18 @@ void raid_rec2_int8(unsigned nrec, const int* d, const int* c, unsigned ndata, u
 	unsigned char V[N*N];
 	unsigned i, j;
 
-	(void)nrec; /* unused */
+	(void)nr; /* unused */
 
 	/* if it's PAR2 uses the dedicated and fastest function */
-	if (c[0] == 0 && c[1] == 1) {
-		raid_rec2_par2(d, c, ndata, size, vbuf, zero);
+	if (ip[0] == 0 && ip[1] == 1) {
+		raid_rec2_par2(id, ip, nd, size, vbuf, zero);
 		return;
 	}
 
 	/* setup the coefficients matrix */
 	for(i=0;i<N;++i) {
 		for(j=0;j<N;++j) {
-			G[i*N+j] = A(c[i],d[j]);
+			G[i*N+j] = A(ip[i],id[j]);
 		}
 	}
 
@@ -2533,12 +2533,12 @@ void raid_rec2_int8(unsigned nrec, const int* d, const int* c, unsigned ndata, u
 	}
 
 	/* compute delta parity */
-	raid_delta_gen(2, d, c, ndata, size, vbuf, zero);
+	raid_delta_gen(2, id, ip, nd, size, vbuf, zero);
 
-	p = vbuf[ndata+c[0]];
-	q = vbuf[ndata+c[1]];
-	pa = vbuf[d[0]];
-	qa = vbuf[d[1]];
+	p = vbuf[nd+ip[0]];
+	q = vbuf[nd+ip[1]];
+	pa = vbuf[id[0]];
+	qa = vbuf[id[1]];
 
 	for(i=0;i<size;++i) {
 		/* delta */
@@ -2552,11 +2552,11 @@ void raid_rec2_int8(unsigned nrec, const int* d, const int* c, unsigned ndata, u
 }
 
 /**
- * Recover failure of N data blocks at indexes d[N] using parity at indexes c[N] for any RAID level.
+ * Recover failure of N data blocks at indexes id[N] using parity at indexes ip[N] for any RAID level.
  *
  * Starting from the N equations, with 0<=i<N :
  *
- * PD[i] = sum(A[c[i],d[j]] * D[i]) 0<=j<N
+ * PD[i] = sum(A[ip[i],id[j]] * D[i]) 0<=j<N
  *
  * we solve inverting the coefficients matrix.
  *
@@ -2564,7 +2564,7 @@ void raid_rec2_int8(unsigned nrec, const int* d, const int* c, unsigned ndata, u
  * PD[0] = Pd, PD[1] = Qd, PD[2] = Rd, ...
  * D[0] = Dx, D[1] = Dy, D[2] = Dz, ...
  */
-void raid_recX_int8(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero)
+void raid_recX_int8(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero)
 {
 	unsigned char* p[RAID_PARITY_CAUCHY_MAX];
 	unsigned char* pa[RAID_PARITY_CAUCHY_MAX];
@@ -2574,41 +2574,41 @@ void raid_recX_int8(unsigned nrec, const int* d, const int* c, unsigned ndata, u
 	unsigned i, j, k;
 
 	/* setup the coefficients matrix */
-	for(i=0;i<nrec;++i) {
-		for(j=0;j<nrec;++j) {
-			G[i*nrec+j] = A(c[i],d[j]);
+	for(i=0;i<nr;++i) {
+		for(j=0;j<nr;++j) {
+			G[i*nr+j] = A(ip[i],id[j]);
 		}
 	}
 
 	/* invert it to solve the system of linear equations */
-	invert(G, V, nrec);
+	invert(G, V, nr);
 
 	/* get multiplication tables */
-	for(i=0;i<nrec;++i) {
-		for(j=0;j<nrec;++j) {
-			T[i][j] = table( V[i*nrec+j] );
+	for(i=0;i<nr;++i) {
+		for(j=0;j<nr;++j) {
+			T[i][j] = table( V[i*nr+j] );
 		}
 	}
 
 	/* compute delta parity */
-	raid_delta_gen(nrec, d, c, ndata, size, vbuf, zero);
+	raid_delta_gen(nr, id, ip, nd, size, vbuf, zero);
 
-	for(i=0;i<nrec;++i) {
-		p[i] = vbuf[ndata+c[i]];
-		pa[i] = vbuf[d[i]];
+	for(i=0;i<nr;++i) {
+		p[i] = vbuf[nd+ip[i]];
+		pa[i] = vbuf[id[i]];
 	}
 
 	for(i=0;i<size;++i) {
 		unsigned char PD[RAID_PARITY_CAUCHY_MAX];
 
 		/* delta */
-		for(j=0;j<nrec;++j)
+		for(j=0;j<nr;++j)
 			PD[j] = p[j][i] ^ pa[j][i];
 
 		/* reconstruct */
-		for(j=0;j<nrec;++j) {
+		for(j=0;j<nr;++j) {
 			unsigned char b = 0;
-			for(k=0;k<nrec;++k)
+			for(k=0;k<nr;++k)
 				b ^= T[j][k][PD[k]];
 			pa[j][i] = b;
 		}
@@ -2619,7 +2619,7 @@ void raid_recX_int8(unsigned nrec, const int* d, const int* c, unsigned ndata, u
 /*
  * RAID recovering for one disk SSSE3 implementation
  */
-void raid_rec1_ssse3(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero)
+void raid_rec1_ssse3(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero)
 {
 	unsigned char* p;
 	unsigned char* pa;
@@ -2627,25 +2627,25 @@ void raid_rec1_ssse3(unsigned nrec, const int* d, const int* c, unsigned ndata,
 	unsigned char V;
 	unsigned i;
 
-	(void)nrec; /* unused */
+	(void)nr; /* unused */
 
 	/* if it's PAR1 uses the dedicated and fastest function */
-	if (c[0] == 0) {
-		raid_rec1_par1(d, ndata, size, vbuf);
+	if (ip[0] == 0) {
+		raid_rec1_par1(id, nd, size, vbuf);
 		return;
 	}
 
 	/* setup the coefficients matrix */
-	G = A(c[0],d[0]);
+	G = A(ip[0],id[0]);
 
 	/* invert it to solve the system of linear equations */
 	V = inv(G);
 
 	/* compute delta parity */
-	raid_delta_gen(1, d, c, ndata, size, vbuf, zero);
+	raid_delta_gen(1, id, ip, nd, size, vbuf, zero);
 
-	p = vbuf[ndata+c[0]];
-	pa = vbuf[d[0]];
+	p = vbuf[nd+ip[0]];
+	pa = vbuf[id[0]];
 
 	asm volatile("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
 	asm volatile("movdqa %0,%%xmm4" : : "m" (gfmulpshufb[V][0][0]));
@@ -2675,7 +2675,7 @@ void raid_rec1_ssse3(unsigned nrec, const int* d, const int* c, unsigned ndata,
 /*
  * RAID recovering for two disks SSSE3 implementation
  */
-void raid_rec2_ssse3(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero)
+void raid_rec2_ssse3(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero)
 {
 	const unsigned N = 2;
 	unsigned char* p[N];
@@ -2684,12 +2684,12 @@ void raid_rec2_ssse3(unsigned nrec, const int* d, const int* c, unsigned ndata,
 	unsigned char V[N*N];
 	unsigned i, j;
 
-	(void)nrec; /* unused */
+	(void)nr; /* unused */
 
 	/* setup the coefficients matrix */
 	for(i=0;i<N;++i) {
 		for(j=0;j<N;++j) {
-			G[i*N+j] = A(c[i],d[j]);
+			G[i*N+j] = A(ip[i],id[j]);
 		}
 	}
 
@@ -2697,11 +2697,11 @@ void raid_rec2_ssse3(unsigned nrec, const int* d, const int* c, unsigned ndata,
 	invert(G, V, N);
 
 	/* compute delta parity */
-	raid_delta_gen(N, d, c, ndata, size, vbuf, zero);
+	raid_delta_gen(N, id, ip, nd, size, vbuf, zero);
 
 	for(i=0;i<N;++i) {
-		p[i] = vbuf[ndata+c[i]];
-		pa[i] = vbuf[d[i]];
+		p[i] = vbuf[nd+ip[i]];
+		pa[i] = vbuf[id[i]];
 	}
 
 	asm volatile("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
@@ -2779,9 +2779,9 @@ void raid_rec2_ssse3(unsigned nrec, const int* d, const int* c, unsigned ndata,
 /*
  * RAID recovering SSSE3 implementation
  */
-void raid_recX_ssse3(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero)
+void raid_recX_ssse3(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero)
 {
-	unsigned N = nrec;
+	unsigned N = nr;
 	unsigned char* p[RAID_PARITY_CAUCHY_MAX];
 	unsigned char* pa[RAID_PARITY_CAUCHY_MAX];
 	unsigned char G[RAID_PARITY_CAUCHY_MAX*RAID_PARITY_CAUCHY_MAX];
@@ -2791,7 +2791,7 @@ void raid_recX_ssse3(unsigned nrec, const int* d, const int* c, unsigned ndata,
 	/* setup the coefficients matrix */
 	for(i=0;i<N;++i) {
 		for(j=0;j<N;++j) {
-			G[i*N+j] = A(c[i],d[j]);
+			G[i*N+j] = A(ip[i],id[j]);
 		}
 	}
 
@@ -2799,11 +2799,11 @@ void raid_recX_ssse3(unsigned nrec, const int* d, const int* c, unsigned ndata,
 	invert(G, V, N);
 
 	/* compute delta parity */
-	raid_delta_gen(N, d, c, ndata, size, vbuf, zero);
+	raid_delta_gen(N, id, ip, nd, size, vbuf, zero);
 
 	for(i=0;i<N;++i) {
-		p[i] = vbuf[ndata+c[i]];
-		pa[i] = vbuf[d[i]];
+		p[i] = vbuf[nd+ip[i]];
+		pa[i] = vbuf[id[i]];
 	}
 
 	asm volatile("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
@@ -2851,24 +2851,24 @@ void raid_recX_ssse3(unsigned nrec, const int* d, const int* c, unsigned ndata,
 #endif
 
 /* internal forwarder */
-static void (*raid_rec1_ptr)(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero);
-static void (*raid_rec2_ptr)(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero);
-static void (*raid_recX_ptr)(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero);
+static void (*raid_rec1_ptr)(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero);
+static void (*raid_rec2_ptr)(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero);
+static void (*raid_recX_ptr)(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero);
 
-void raid_rec(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero)
+void raid_rec(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero)
 {
-	switch (nrec) {
+	switch (nr) {
 	case 1 :
-		raid_rec1_ptr(nrec, d, c, ndata, size, vbuf, zero);
+		raid_rec1_ptr(nr, id, ip, nd, size, vbuf, zero);
 		break;
 	case 2 :
-		raid_rec2_ptr(nrec, d, c, ndata, size, vbuf, zero);
+		raid_rec2_ptr(nr, id, ip, nd, size, vbuf, zero);
 		break;
 	case 3 :
 	case 4 :
 	case 5 :
 	case 6 :
-		raid_recX_ptr(nrec, d, c, ndata, size, vbuf, zero);
+		raid_recX_ptr(nr, id, ip, nd, size, vbuf, zero);
 		break;
 	default:
 		fprintf(stderr, "Invalid raid recov level\n");
diff --git a/raid.h b/raid.h
index 94311979..1301a612 100644
--- a/raid.h
+++ b/raid.h
@@ -73,28 +73,28 @@ void raid_set(unsigned mode);
 /**
  * Computes the parity.
  *
- * \param npar Number of parities to compute.
- * \param ndata Number of data disks.
+ * \param np Number of parities to compute.
+ * \param nd Number of data disks.
  * \param size Size of the blocks pointed by vbuf. It must be a power of 2, and at least 64.
  * \param vbuf Vector of pointers to the blocks for disks and parities.
- * It has (::ndata + ::npar) elements. Each element points to a buffer of ::size bytes. 
+ * It has (::nd + ::np) elements. Each element points to a buffer of ::size bytes. 
  */
-void raid_par(unsigned npar, unsigned ndata, unsigned size, unsigned char** vbuf);
+void raid_par(unsigned np, unsigned nd, unsigned size, unsigned char** vbuf);
 
 /**
  * Recovers failures of data disks using the specified parities.
  *
  * Note that only the data blocks are recovered. The parity is destroyed.
- * \param nrec Number of failed disks to recover.
- * \param d[] Vector of indexes of the data disks to recover. Starting from 0.
- * \param c[] Vector of indexes of the checksum/parity to use for the recovering. Starting from 0.
- * \param ndata Number of data disks.
+ * \param nr Number of failed disks to recover.
+ * \param id[] Vector of ::nr indexes of the data disks to recover. Starting from 0.
+ * \param ip[] Vector of ::nr indexes of the parity to use for the recovering. Starting from 0.
+ * \param nd Number of data disks.
  * \param size Size of the blocks pointed by vbuf. It must be a power of 2, and at least 64.
  * \param vbuf Vector of pointers to the blocks for disks and parities.
- * It has (::ndata + max(::c[] + 1)) elements. Each element points to a buffer of ::size bytes.
+ * It has (::nd + max(::ip[] + 1)) elements. Each element points to a buffer of ::size bytes.
  * \param zero Buffer filled with 0 of ::size bytes. This buffer is not modified. 
  */
-void raid_rec(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero);
+void raid_rec(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero);
 
 /**
  * Gets the name of the selected function to compute the parity.
@@ -115,34 +115,34 @@ const char* raid_recX_tag(void);
  * Specialized parity computation.
  * Only for testing.
  */
-void raid_par1_int32(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par1_int64(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par1_sse2(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par2_int32(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par2_int64(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par2_sse2(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par2_sse2ext(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_parz_int32(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_parz_int64(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_parz_sse2(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_parz_sse2ext(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par3_int8(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par3_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par3_ssse3ext(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par4_int8(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par4_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par4_ssse3ext(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par5_int8(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par5_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par5_ssse3ext(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par6_int8(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par6_ssse3(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_par6_ssse3ext(unsigned ndata, unsigned size, unsigned char** vbuf);
-void raid_rec1_int8(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero);
-void raid_rec2_int8(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero);
-void raid_recX_int8(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero);
-void raid_rec1_ssse3(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero);
-void raid_rec2_ssse3(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero);
-void raid_recX_ssse3(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero);
+void raid_par1_int32(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par1_int64(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par1_sse2(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par2_int32(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par2_int64(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par2_sse2(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par2_sse2ext(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_parz_int32(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_parz_int64(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_parz_sse2(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_parz_sse2ext(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par3_int8(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par3_ssse3(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par3_ssse3ext(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par4_int8(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par4_ssse3(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par4_ssse3ext(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par5_int8(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par5_ssse3(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par5_ssse3ext(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par6_int8(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par6_ssse3(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_par6_ssse3ext(unsigned nd, unsigned size, unsigned char** vbuf);
+void raid_rec1_int8(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero);
+void raid_rec2_int8(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero);
+void raid_recX_int8(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero);
+void raid_rec1_ssse3(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero);
+void raid_rec2_ssse3(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero);
+void raid_recX_ssse3(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero);
 
 #endif
diff --git a/selftest.c b/selftest.c
index 65476d3d..76134307 100644
--- a/selftest.c
+++ b/selftest.c
@@ -80,7 +80,7 @@ static void combotest(void)
 	}
 }
 
-static void recovtest(unsigned mode, unsigned ndata, unsigned block_size)
+static void recovtest(unsigned mode, unsigned nd, unsigned block_size)
 {
 	void* buffer_alloc;
 	unsigned char** buffer;
@@ -92,31 +92,31 @@ static void recovtest(unsigned mode, unsigned ndata, unsigned block_size)
 	unsigned char* zero;
 	unsigned char* waste;
 	unsigned buffermax;
-	int d[LEV_MAX];
-	int c[LEV_MAX];
+	int id[LEV_MAX];
+	int ip[LEV_MAX];
 	unsigned i;
 	unsigned j;
-	unsigned nrec;
-	void (*map[LEV_MAX][4])(unsigned nrec, const int* d, const int* c, unsigned ndata, unsigned size, unsigned char** vbuf, unsigned char* zero);
+	unsigned nr;
+	void (*map[LEV_MAX][4])(unsigned nr, const int* id, const int* ip, unsigned nd, unsigned size, unsigned char** vbuf, unsigned char* zero);
 	unsigned mac[LEV_MAX];
-	unsigned npar;
+	unsigned np;
 
 	raid_set(mode);
 	if (mode == RAID_MODE_CAUCHY)
-		npar = RAID_PARITY_CAUCHY_MAX;
+		np = RAID_PARITY_CAUCHY_MAX;
 	else
-		npar = RAID_PARITY_VANDERMONDE_MAX;
+		np = RAID_PARITY_VANDERMONDE_MAX;
 
-	buffermax = ndata + npar * 2 + 2;
+	buffermax = nd + np * 2 + 2;
 
-	buffer = malloc_nofail_vector_align(ndata, buffermax, block_size, &buffer_alloc);
+	buffer = malloc_nofail_vector_align(nd, buffermax, block_size, &buffer_alloc);
 	mtest_vector(buffer, buffermax, block_size);
 
 	data = buffer;
-	parity = buffer + ndata;
-	test = buffer + ndata + npar;
+	parity = buffer + nd;
+	test = buffer + nd + np;
 
-	for(i=0;i<npar;++i)
+	for(i=0;i<np;++i)
 		parity_save[i] = parity[i];
 
 	zero = buffer[buffermax-2];
@@ -125,13 +125,13 @@ static void recovtest(unsigned mode, unsigned ndata, unsigned block_size)
 	waste = buffer[buffermax-1];
 
 	/* fill data disk with random */
-	for(i=0;i<ndata;++i) {
+	for(i=0;i<nd;++i) {
 		for(j=0;j<block_size;++j)
 			data[i][j] = rand();
 	}
 
 	/* setup recov functions */
-	for(i=0;i<npar;++i) {
+	for(i=0;i<np;++i) {
 		mac[i] = 0;
 		if (i == 0) {
 			map[i][mac[i]++] = raid_rec1_int8;
@@ -158,36 +158,36 @@ static void recovtest(unsigned mode, unsigned ndata, unsigned block_size)
 	}
 
 	/* compute the parity */
-	raid_par(npar, ndata, block_size, buffer);
+	raid_par(np, nd, block_size, buffer);
 
 	/* set all the parity to the waste buffer */
-	for(i=0;i<npar;++i)
+	for(i=0;i<np;++i)
 		parity[i] = waste;
 
 	/* all parity levels */
-	for(nrec=1;nrec<=npar;++nrec) {
-		/* all combinations (nrec of ndata) disks */
-		combination_first(nrec, ndata, d);
+	for(nr=1;nr<=np;++nr) {
+		/* all combinations (nr of nd) disks */
+		combination_first(nr, nd, id);
 		do {
-			/* all combinations (nrec of npar) parities */
-			combination_first(nrec, npar, c);
+			/* all combinations (nr of np) parities */
+			combination_first(nr, np, ip);
 			do {
 				/* for each recover function */
-				for(j=0;j<mac[nrec-1];++j) {
+				for(j=0;j<mac[nr-1];++j) {
 					/* set */
-					for(i=0;i<nrec;++i) {
+					for(i=0;i<nr;++i) {
 						/* remove the missing data */
-						data_save[i] = data[d[i]];
-						data[d[i]] = test[i];
+						data_save[i] = data[id[i]];
+						data[id[i]] = test[i];
 						/* set the parity to use */
-						parity[c[i]] = parity_save[c[i]];
+						parity[ip[i]] = parity_save[ip[i]];
 					}
 
 					/* recover */
-					map[nrec-1][0](nrec, d, c, ndata, block_size, buffer, zero);
+					map[nr-1][0](nr, id, ip, nd, block_size, buffer, zero);
 
 					/* check */
-					for(i=0;i<nrec;++i) {
+					for(i=0;i<nr;++i) {
 						if (memcmp(test[i], data_save[i], block_size) != 0) {
 							fprintf(stderr, "Failed RECOV test\n");
 							exit(EXIT_FAILURE);
@@ -195,54 +195,54 @@ static void recovtest(unsigned mode, unsigned ndata, unsigned block_size)
 					}
 
 					/* restore */
-					for(i=0;i<nrec;++i) {
+					for(i=0;i<nr;++i) {
 						/* restore the data */
-						data[d[i]] = data_save[i];
+						data[id[i]] = data_save[i];
 						/* restore the parity */
-						parity[c[i]] = waste;
+						parity[ip[i]] = waste;
 					}
 				}
-			} while (combination_next(nrec, npar, c));
-		} while (combination_next(nrec, ndata, d));
+			} while (combination_next(nr, np, ip));
+		} while (combination_next(nr, nd, id));
 	}
 
 	free(buffer_alloc);
 	free(buffer);
 }
 
-static void gentest(unsigned mode, unsigned ndata, unsigned block_size)
+static void gentest(unsigned mode, unsigned nd, unsigned block_size)
 {
 	void* buffer_alloc;
 	unsigned char** buffer;
 	unsigned buffermax;
 	unsigned i, j;
-	void (*map[64])(unsigned ndata, unsigned size, unsigned char** vbuf);
+	void (*map[64])(unsigned nd, unsigned size, unsigned char** vbuf);
 	unsigned mac;
-	unsigned npar;
+	unsigned np;
 
 	raid_set(mode);
 	if (mode == RAID_MODE_CAUCHY)
-		npar = RAID_PARITY_CAUCHY_MAX;
+		np = RAID_PARITY_CAUCHY_MAX;
 	else
-		npar = RAID_PARITY_VANDERMONDE_MAX;
+		np = RAID_PARITY_VANDERMONDE_MAX;
 
-	buffermax = ndata + npar * 2;
+	buffermax = nd + np * 2;
 
-	buffer = malloc_nofail_vector_align(ndata, buffermax, block_size, &buffer_alloc);
+	buffer = malloc_nofail_vector_align(nd, buffermax, block_size, &buffer_alloc);
 	mtest_vector(buffer, buffermax, block_size);
 
 	/* fill with random */
-	for(i=0;i<ndata;++i) {
+	for(i=0;i<nd;++i) {
 		for(j=0;j<block_size;++j)
 			buffer[i][j] = rand();
 	}
 
 	/* compute the parity */
-	raid_par(npar, ndata, block_size, buffer);
+	raid_par(np, nd, block_size, buffer);
 
 	/* copy in back buffers */
-	for(i=0;i<npar;++i)
-		memcpy(buffer[ndata + npar + i], buffer[ndata + i], block_size);
+	for(i=0;i<np;++i)
+		memcpy(buffer[nd + np + i], buffer[nd + i], block_size);
 
 	/* load all the available functions */
 	mac = 0;
@@ -296,11 +296,11 @@ static void gentest(unsigned mode, unsigned ndata, unsigned block_size)
 	/* check all the functions */
 	for(j=0;j<mac;++j) {
 		/* compute parity */
-		map[j](ndata, block_size, buffer);
+		map[j](nd, block_size, buffer);
 
 		/* check it */
-		for(i=0;i<npar;++i) {
-			if (memcmp(buffer[ndata + npar + i], buffer[ndata + i], block_size) != 0) {
+		for(i=0;i<np;++i) {
+			if (memcmp(buffer[nd + np + i], buffer[nd + i], block_size) != 0) {
 				fprintf(stderr, "Failed GEN test\n");
 				exit(EXIT_FAILURE);
 			}
diff --git a/speed.c b/speed.c
index 7dcd3a03..44c8602f 100644
--- a/speed.c
+++ b/speed.c
@@ -47,7 +47,7 @@ static int64_t diffgettimeofday(struct timeval* start, struct timeval* stop)
 		count += delta; \
 		gettimeofday(&stop, 0); \
 	} while (diffgettimeofday(&start, &stop) < 1000000LL); \
-	ds = block_size * (int64_t)count * ndata; \
+	ds = block_size * (int64_t)count * nd; \
 	dt = diffgettimeofday(&start, &stop);
 
 void speed(void)
@@ -59,30 +59,30 @@ void speed(void)
 	unsigned i, j;
 	unsigned char digest[HASH_SIZE];
 	unsigned char seed[HASH_SIZE];
-	int d[LEV_MAX];
-	int c[LEV_MAX];
+	int id[LEV_MAX];
+	int ip[LEV_MAX];
 	unsigned count;
 	unsigned delta = 10;
 	unsigned block_size = 256 * 1024;
-	unsigned ndata = 8;
+	unsigned nd = 8;
 	unsigned buffermax;
 	void* buffer_alloc;
 	unsigned char** buffer;
 	unsigned char* zero;
 
 	/* we need disk + 1 for each parity buffers + 1 zero buffer */
-	buffermax = ndata + LEV_MAX + 1;
+	buffermax = nd + LEV_MAX + 1;
 
-	buffer = malloc_nofail_vector_align(ndata, buffermax, block_size, &buffer_alloc);
+	buffer = malloc_nofail_vector_align(nd, buffermax, block_size, &buffer_alloc);
 	mtest_vector(buffer, buffermax, block_size);
 
 	/* initialize disks with fixed data */
-	for(i=0;i<ndata;++i) {
+	for(i=0;i<nd;++i) {
 		memset(buffer[i], i, block_size);
 	}
 
 	/* zero buffer */
-	zero = buffer[ndata+LEV_MAX];
+	zero = buffer[nd+LEV_MAX];
 	memset(zero, 0, block_size);
 
 	/* hash seed */
@@ -92,8 +92,8 @@ void speed(void)
 
 	/* basic disks and parity mapping */
 	for(i=0;i<LEV_MAX;++i) {
-		d[i] = i;
-		c[i] = i;
+		id[i] = i;
+		ip[i] = i;
 	}
 
 	printf(PACKAGE " v" VERSION " by Andrea Mazzoleni, " PACKAGE_URL "\n");
@@ -142,7 +142,7 @@ void speed(void)
 
 	printf("\n");
 
-	printf("Speed test using %u buffers of %u bytes, for a total of %u KiB.\n", ndata, block_size, ndata * block_size / 1024);
+	printf("Speed test using %u buffers of %u bytes, for a total of %u KiB.\n", nd, block_size, nd * block_size / 1024);
 	printf("The reported value is the sustainable aggregate bandwidth of all data disks in MiB/s (not counting parity disks).\n");
 	printf("\n");
 
@@ -151,7 +151,7 @@ void speed(void)
 	fflush(stdout);
 
 	SPEED_START {
-		for(j=0;j<ndata;++j) {
+		for(j=0;j<nd;++j) {
 			memset(buffer[j], j, block_size);
 		}
 	} SPEED_STOP
@@ -167,7 +167,7 @@ void speed(void)
 	fflush(stdout);
 
 	SPEED_START {
-		for(j=0;j<ndata;++j) {
+		for(j=0;j<nd;++j) {
 			crc32c_gen(0, buffer[j], block_size);
 		}
 	} SPEED_STOP
@@ -181,7 +181,7 @@ void speed(void)
 #if HAVE_CRC32B
 	if (cpu_has_sse42()) {
 		SPEED_START {
-			for(j=0;j<ndata;++j) {
+			for(j=0;j<nd;++j) {
 				crc32c_x86(0, buffer[j], block_size);
 			}
 		} SPEED_STOP
@@ -216,7 +216,7 @@ void speed(void)
 	fflush(stdout);
 
 	SPEED_START {
-		for(j=0;j<ndata;++j) {
+		for(j=0;j<nd;++j) {
 			memhash(HASH_MURMUR3, seed, digest, buffer[j], block_size);
 		}
 	} SPEED_STOP
@@ -225,7 +225,7 @@ void speed(void)
 	fflush(stdout);
 
 	SPEED_START {
-		for(j=0;j<ndata;++j) {
+		for(j=0;j<nd;++j) {
 			memhash(HASH_SPOOKY2, seed, digest, buffer[j], block_size);
 		}
 	} SPEED_STOP
@@ -261,14 +261,14 @@ void speed(void)
 	printf("%8s", "");
 
 	SPEED_START {
-		raid_par1_int32(ndata, block_size, buffer);
+		raid_par1_int32(nd, block_size, buffer);
 	} SPEED_STOP
 
 	printf("%8"PRIu64, ds / dt);
 	fflush(stdout);
 
 	SPEED_START {
-		raid_par1_int64(ndata, block_size, buffer);
+		raid_par1_int64(nd, block_size, buffer);
 	} SPEED_STOP
 
 	printf("%8"PRIu64, ds / dt);
@@ -277,7 +277,7 @@ void speed(void)
 #if defined(__i386__) || defined(__x86_64__)
 	if (cpu_has_sse2()) {
 		SPEED_START {
-			raid_par1_sse2(ndata, block_size, buffer);
+			raid_par1_sse2(nd, block_size, buffer);
 		} SPEED_STOP
 
 		printf("%8"PRIu64, ds / dt);
@@ -294,14 +294,14 @@ void speed(void)
 	printf("%8s", "");
 
 	SPEED_START {
-		raid_par2_int32(ndata, block_size, buffer);
+		raid_par2_int32(nd, block_size, buffer);
 	} SPEED_STOP
 
 	printf("%8"PRIu64, ds / dt);
 	fflush(stdout);
 
 	SPEED_START {
-		raid_par2_int64(ndata, block_size, buffer);
+		raid_par2_int64(nd, block_size, buffer);
 	} SPEED_STOP
 
 	printf("%8"PRIu64, ds / dt);
@@ -310,7 +310,7 @@ void speed(void)
 #if defined(__i386__) || defined(__x86_64__)
 	if (cpu_has_sse2()) {
 		SPEED_START {
-			raid_par2_sse2(ndata, block_size, buffer);
+			raid_par2_sse2(nd, block_size, buffer);
 		} SPEED_STOP
 
 		printf("%8"PRIu64, ds / dt);
@@ -318,7 +318,7 @@ void speed(void)
 
 #if defined(__x86_64__)
 		SPEED_START {
-			raid_par2_sse2ext(ndata, block_size, buffer);
+			raid_par2_sse2ext(nd, block_size, buffer);
 		} SPEED_STOP
 
 		printf("%8"PRIu64, ds / dt);
@@ -336,14 +336,14 @@ void speed(void)
 	printf("%8s", "");
 
 	SPEED_START {
-		raid_parz_int32(ndata, block_size, buffer);
+		raid_parz_int32(nd, block_size, buffer);
 	} SPEED_STOP
 
 	printf("%8"PRIu64, ds / dt);
 	fflush(stdout);
 
 	SPEED_START {
-		raid_parz_int64(ndata, block_size, buffer);
+		raid_parz_int64(nd, block_size, buffer);
 	} SPEED_STOP
 
 	printf("%8"PRIu64, ds / dt);
@@ -352,7 +352,7 @@ void speed(void)
 #if defined(__i386__) || defined(__x86_64__)
 	if (cpu_has_sse2()) {
 		SPEED_START {
-			raid_parz_sse2(ndata, block_size, buffer);
+			raid_parz_sse2(nd, block_size, buffer);
 		} SPEED_STOP
 
 		printf("%8"PRIu64, ds / dt);
@@ -360,7 +360,7 @@ void speed(void)
 
 #if defined(__x86_64__)
 		SPEED_START {
-			raid_parz_sse2ext(ndata, block_size, buffer);
+			raid_parz_sse2ext(nd, block_size, buffer);
 		} SPEED_STOP
 
 		printf("%8"PRIu64, ds / dt);
@@ -376,7 +376,7 @@ void speed(void)
 	fflush(stdout);
 
 	SPEED_START {
-		raid_par3_int8(ndata, block_size, buffer);
+		raid_par3_int8(nd, block_size, buffer);
 	} SPEED_STOP
 
 	printf("%8"PRIu64, ds / dt);
@@ -396,7 +396,7 @@ void speed(void)
 #if defined(__i386__) || defined(__x86_64__)
 	if (cpu_has_ssse3()) {
 		SPEED_START {
-			raid_par3_ssse3(ndata, block_size, buffer);
+			raid_par3_ssse3(nd, block_size, buffer);
 		} SPEED_STOP
 
 		printf("%8"PRIu64, ds / dt);
@@ -404,7 +404,7 @@ void speed(void)
 
 #if defined(__x86_64__)
 		SPEED_START {
-			raid_par3_ssse3ext(ndata, block_size, buffer);
+			raid_par3_ssse3ext(nd, block_size, buffer);
 		} SPEED_STOP
 
 		printf("%8"PRIu64, ds / dt);
@@ -420,7 +420,7 @@ void speed(void)
 	fflush(stdout);
 
 	SPEED_START {
-		raid_par4_int8(ndata, block_size, buffer);
+		raid_par4_int8(nd, block_size, buffer);
 	} SPEED_STOP
 
 	printf("%8"PRIu64, ds / dt);
@@ -440,7 +440,7 @@ void speed(void)
 #if defined(__i386__) || defined(__x86_64__)
 	if (cpu_has_ssse3()) {
 		SPEED_START {
-			raid_par4_ssse3(ndata, block_size, buffer);
+			raid_par4_ssse3(nd, block_size, buffer);
 		} SPEED_STOP
 
 		printf("%8"PRIu64, ds / dt);
@@ -448,7 +448,7 @@ void speed(void)
 
 #if defined(__x86_64__)
 		SPEED_START {
-			raid_par4_ssse3ext(ndata, block_size, buffer);
+			raid_par4_ssse3ext(nd, block_size, buffer);
 		} SPEED_STOP
 
 		printf("%8"PRIu64, ds / dt);
@@ -464,7 +464,7 @@ void speed(void)
 	fflush(stdout);
 
 	SPEED_START {
-		raid_par5_int8(ndata, block_size, buffer);
+		raid_par5_int8(nd, block_size, buffer);
 	} SPEED_STOP
 
 	printf("%8"PRIu64, ds / dt);
@@ -484,7 +484,7 @@ void speed(void)
 #if defined(__i386__) || defined(__x86_64__)
 	if (cpu_has_ssse3()) {
 		SPEED_START {
-			raid_par5_ssse3(ndata, block_size, buffer);
+			raid_par5_ssse3(nd, block_size, buffer);
 		} SPEED_STOP
 
 		printf("%8"PRIu64, ds / dt);
@@ -492,7 +492,7 @@ void speed(void)
 
 #if defined(__x86_64__)
 		SPEED_START {
-			raid_par5_ssse3ext(ndata, block_size, buffer);
+			raid_par5_ssse3ext(nd, block_size, buffer);
 		} SPEED_STOP
 
 		printf("%8"PRIu64, ds / dt);
@@ -508,7 +508,7 @@ void speed(void)
 	fflush(stdout);
 
 	SPEED_START {
-		raid_par6_int8(ndata, block_size, buffer);
+		raid_par6_int8(nd, block_size, buffer);
 	} SPEED_STOP
 
 	printf("%8"PRIu64, ds / dt);
@@ -528,7 +528,7 @@ void speed(void)
 #if defined(__i386__) || defined(__x86_64__)
 	if (cpu_has_ssse3()) {
 		SPEED_START {
-			raid_par6_ssse3(ndata, block_size, buffer);
+			raid_par6_ssse3(nd, block_size, buffer);
 		} SPEED_STOP
 
 		printf("%8"PRIu64, ds / dt);
@@ -536,7 +536,7 @@ void speed(void)
 
 #if defined(__x86_64__)
 		SPEED_START {
-			raid_par6_ssse3ext(ndata, block_size, buffer);
+			raid_par6_ssse3ext(nd, block_size, buffer);
 		} SPEED_STOP
 
 		printf("%8"PRIu64, ds / dt);
@@ -560,9 +560,9 @@ void speed(void)
 	fflush(stdout);
 
 	SPEED_START {
-		for(j=0;j<ndata;++j) {
+		for(j=0;j<nd;++j) {
 			/* +1 to avoid PAR1 optimized case */
-			raid_rec1_int8(1, d, c + 1, ndata, block_size, buffer, zero);
+			raid_rec1_int8(1, id, ip + 1, nd, block_size, buffer, zero);
 		}
 	} SPEED_STOP
 
@@ -572,9 +572,9 @@ void speed(void)
 #if defined(__i386__) || defined(__x86_64__)
 	if (cpu_has_ssse3()) {
 		SPEED_START {
-			for(j=0;j<ndata;++j) {
+			for(j=0;j<nd;++j) {
 				/* +1 to avoid PAR1 optimized case */
-				raid_rec1_ssse3(1, d, c + 1, ndata, block_size, buffer, zero);
+				raid_rec1_ssse3(1, id, ip + 1, nd, block_size, buffer, zero);
 			}
 		} SPEED_STOP
 
@@ -588,9 +588,9 @@ void speed(void)
 	fflush(stdout);
 
 	SPEED_START {
-		for(j=0;j<ndata;++j) {
+		for(j=0;j<nd;++j) {
 			/* +1 to avoid PAR2 optimized case */
-			raid_rec2_int8(2, d, c + 1, ndata, block_size, buffer, zero);
+			raid_rec2_int8(2, id, ip + 1, nd, block_size, buffer, zero);
 		}
 	} SPEED_STOP
 
@@ -600,9 +600,9 @@ void speed(void)
 #if defined(__i386__) || defined(__x86_64__)
 	if (cpu_has_ssse3()) {
 		SPEED_START {
-			for(j=0;j<ndata;++j) {
+			for(j=0;j<nd;++j) {
 				/* +1 to avoid PAR2 optimized case */
-				raid_rec2_ssse3(2, d, c + 1, ndata, block_size, buffer, zero);
+				raid_rec2_ssse3(2, id, ip + 1, nd, block_size, buffer, zero);
 			}
 		} SPEED_STOP
 
@@ -616,8 +616,8 @@ void speed(void)
 	fflush(stdout);
 
 	SPEED_START {
-		for(j=0;j<ndata;++j) {
-			raid_recX_int8(3, d, c, ndata, block_size, buffer, zero);
+		for(j=0;j<nd;++j) {
+			raid_recX_int8(3, id, ip, nd, block_size, buffer, zero);
 		}
 	} SPEED_STOP
 
@@ -627,8 +627,8 @@ void speed(void)
 #if defined(__i386__) || defined(__x86_64__)
 	if (cpu_has_ssse3()) {
 		SPEED_START {
-			for(j=0;j<ndata;++j) {
-				raid_recX_ssse3(3, d, c, ndata, block_size, buffer, zero);
+			for(j=0;j<nd;++j) {
+				raid_recX_ssse3(3, id, ip, nd, block_size, buffer, zero);
 			}
 		} SPEED_STOP
 
@@ -642,8 +642,8 @@ void speed(void)
 	fflush(stdout);
 
 	SPEED_START {
-		for(j=0;j<ndata;++j) {
-			raid_recX_int8(4, d, c, ndata, block_size, buffer, zero);
+		for(j=0;j<nd;++j) {
+			raid_recX_int8(4, id, ip, nd, block_size, buffer, zero);
 		}
 	} SPEED_STOP
 
@@ -653,8 +653,8 @@ void speed(void)
 #if defined(__i386__) || defined(__x86_64__)
 	if (cpu_has_ssse3()) {
 		SPEED_START {
-			for(j=0;j<ndata;++j) {
-				raid_recX_ssse3(4, d, c, ndata, block_size, buffer, zero);
+			for(j=0;j<nd;++j) {
+				raid_recX_ssse3(4, id, ip, nd, block_size, buffer, zero);
 			}
 		} SPEED_STOP
 
@@ -668,8 +668,8 @@ void speed(void)
 	fflush(stdout);
 
 	SPEED_START {
-		for(j=0;j<ndata;++j) {
-			raid_recX_int8(5, d, c, ndata, block_size, buffer, zero);
+		for(j=0;j<nd;++j) {
+			raid_recX_int8(5, id, ip, nd, block_size, buffer, zero);
 		}
 	} SPEED_STOP
 
@@ -679,8 +679,8 @@ void speed(void)
 #if defined(__i386__) || defined(__x86_64__)
 	if (cpu_has_ssse3()) {
 		SPEED_START {
-			for(j=0;j<ndata;++j) {
-				raid_recX_ssse3(5, d, c, ndata, block_size, buffer, zero);
+			for(j=0;j<nd;++j) {
+				raid_recX_ssse3(5, id, ip, nd, block_size, buffer, zero);
 			}
 		} SPEED_STOP
 
@@ -694,8 +694,8 @@ void speed(void)
 	fflush(stdout);
 
 	SPEED_START {
-		for(j=0;j<ndata;++j) {
-			raid_recX_int8(6, d, c, ndata, block_size, buffer, zero);
+		for(j=0;j<nd;++j) {
+			raid_recX_int8(6, id, ip, nd, block_size, buffer, zero);
 		}
 	} SPEED_STOP
 
@@ -705,8 +705,8 @@ void speed(void)
 #if defined(__i386__) || defined(__x86_64__)
 	if (cpu_has_ssse3()) {
 		SPEED_START {
-			for(j=0;j<ndata;++j) {
-				raid_recX_ssse3(6, d, c, ndata, block_size, buffer, zero);
+			for(j=0;j<nd;++j) {
+				raid_recX_ssse3(6, id, ip, nd, block_size, buffer, zero);
 			}
 		} SPEED_STOP