int main(int argc, char **argv)
{
uint32_t a, b, c;
uint8_t *r1, *r2;
uint16_t *r16;
uint32_t *r32;
int w, i;
gf_t gf;
if (argc != 2) usage(NULL);
w = atoi(argv[1]);
if (w <= 0 || w > 32) usage("Bad w");
/* Get two random numbers in a and b */
MOA_Seed(time(0));
a = MOA_Random_W(w, 0);
b = MOA_Random_W(w, 0);
/* Create the proper instance of the gf_t object using defaults: */
gf_init_easy(&gf, w);
/* And multiply a and b using the galois field: */
c = gf.multiply.w32(&gf, a, b);
printf("%u * %u = %u\n", a, b, c);
/* Divide the product by a and b */
printf("%u / %u = %u\n", c, a, gf.divide.w32(&gf, c, a));
printf("%u / %u = %u\n", c, b, gf.divide.w32(&gf, c, b));
/* If w is 4, 8, 16 or 32, do a very small region operation */
if (w == 4 || w == 8 || w == 16 || w == 32) {
r1 = (uint8_t *) malloc(16);
r2 = (uint8_t *) malloc(16);
if (w == 4 || w == 8) {
r1[0] = b;
for (i = 1; i < 16; i++) r1[i] = MOA_Random_W(8, 1);
} else if (w == 16) {
r16 = (uint16_t *) r1;
r16[0] = b;
for (i = 1; i < 8; i++) r16[i] = MOA_Random_W(16, 1);
} else {
r32 = (uint32_t *) r1;
r32[0] = b;
for (i = 1; i < 4; i++) r32[i] = MOA_Random_W(32, 1);
}
gf.multiply_region.w32(&gf, r1, r2, a, 16, 0);
printf("\nmultiply_region by 0x%x (%u)\n\n", a, a);
printf("R1 (the source): ");
if (w == 4) {
for (i = 0; i < 16; i++) printf(" %x %x", r1[i] >> 4, r1[i] & 0xf);
} else if (w == 8) {
void MOA_Fill_Random_Region (void *reg, int size)
{
uint32_t *r32;
uint8_t *r8;
int i;
r32 = (uint32_t *) reg;
r8 = (uint8_t *) reg;
for (i = 0; i < size/4; i++) r32[i] = MOA_Random_32();
for (i *= 4; i < size; i++) r8[i] = MOA_Random_W(8, 1);
}
int main(int argc, char **argv)
{
uint16_t *a, *b;
int i, j;
gf_t gf;
if (gf_init_hard(&gf, 16, GF_MULT_SPLIT_TABLE, GF_REGION_ALTMAP, GF_DIVIDE_DEFAULT,
0, 16, 4, NULL, NULL) == 0) {
fprintf(stderr, "gf_init_hard failed\n");
exit(1);
}
a = (uint16_t *) malloc(200);
b = (uint16_t *) malloc(200);
a += 6;
b += 6;
MOA_Seed(0);
for (i = 0; i < 30; i++) a[i] = MOA_Random_W(16, 1);
gf.multiply_region.w32(&gf, a, b, 0x1234, 30*2, 0);
printf("a: 0x%lx b: 0x%lx\n", (unsigned long) a, (unsigned long) b);
for (i = 0; i < 30; i += 10) {
printf("\n");
printf(" ");
for (j = 0; j < 10; j++) printf(" %4d", i+j);
printf("\n");
printf("a:");
for (j = 0; j < 10; j++) printf(" %04x", a[i+j]);
printf("\n");
printf("b:");
for (j = 0; j < 10; j++) printf(" %04x", b[i+j]);
printf("\n");
printf("\n");
}
for (i = 0; i < 15; i ++) {
printf("Word %2d: 0x%04x * 0x1234 = 0x%04x ", i,
gf.extract_word.w32(&gf, a, 30*2, i),
gf.extract_word.w32(&gf, b, 30*2, i));
printf("Word %2d: 0x%04x * 0x1234 = 0x%04x\n", i+15,
gf.extract_word.w32(&gf, a, 30*2, i+15),
gf.extract_word.w32(&gf, b, 30*2, i+15));
}
return 0;
}
int main(int argc, char **argv)
{
unsigned char *x, *y;
unsigned short *xs, *ys;
unsigned int *xi, *yi;
uint32_t seed;
int *a32, *copy;
int i;
int w;
if (argc != 3) usage(NULL);
if (sscanf(argv[1], "%d", &w) == 0 || (w != 8 && w != 16 && w != 32)) usage("Bad w");
if (sscanf(argv[2], "%d", &seed) == 0) usage("Bad seed");
printf("<HTML><TITLE>reed_sol_04 %d %d</title>\n", w, seed);
printf("<h3>reed_sol_04 %d %d</h3>\n", w, seed);
printf("<pre>\n");
MOA_Seed(seed);
a32 = talloc(int, 4);
copy = talloc(int, 4);
y = (unsigned char *) a32;
for (i = 0; i < 4*sizeof(int); i++) y[i] = MOA_Random_W(8, 1);
memcpy(copy, a32, sizeof(int)*4);
if (w == 8) {
x = (unsigned char *) copy;
y = (unsigned char *) a32;
reed_sol_galois_w08_region_multby_2((char *) a32, sizeof(int)*4);
for (i = 0; i < 4*sizeof(int)/sizeof(char); i++) {
printf("Char %2d: %3u *2 = %3u\n", i, x[i], y[i]);
}
} else if (w == 16) {
xs = (unsigned short *) copy;
ys = (unsigned short *) a32;
reed_sol_galois_w16_region_multby_2((char *) a32, sizeof(int)*4);
for (i = 0; i < 4*sizeof(int)/sizeof(short); i++) {
printf("Short %2d: %5u *2 = %5u\n", i, xs[i], ys[i]);
}
} else if (w == 32) {
xi = (unsigned int *) copy;
yi = (unsigned int *) a32;
reed_sol_galois_w16_region_multby_2((char *) a32, sizeof(int)*4);
for (i = 0; i < 4*sizeof(int)/sizeof(int); i++) {
printf("Int %2d: %10u *2 = %10u\n", i, xi[i], yi[i]);
}
}
}
void gf_general_set_random(gf_general_t *v, int w, int zero_ok)
{
if (w <= 32) {
v->w32 = MOA_Random_W(w, zero_ok);
} else if (w <= 64) {
while (1) {
v->w64 = MOA_Random_64();
if (v->w64 != 0 || zero_ok) return;
}
} else {
while (1) {
MOA_Random_128(v->w128);
if (v->w128[0] != 0 || v->w128[1] != 0 || zero_ok) return;
}
}
}
void gf_general_set_up_single_timing_test(int w, void *ra, void *rb, int size)
{
void *top;
gf_general_t g;
uint8_t *r8, *r8a;
uint16_t *r16;
uint32_t *r32;
uint64_t *r64;
int i;
top = rb+size;
/* If w is 8, 16, 32, 64 or 128, fill the regions with random bytes.
However, don't allow for zeros in rb, because that will screw up
division.
When w is 4, you fill the regions with random 4-bit words in each byte.
Otherwise, treat every four bytes as an uint32_t
and fill it with a random value mod (1 << w).
*/
if (w == 8 || w == 16 || w == 32 || w == 64 || w == 128) {
MOA_Fill_Random_Region (ra, size);
while (rb < top) {
gf_general_set_random(&g, w, 0);
switch (w) {
case 8:
r8 = (uint8_t *) rb;
*r8 = g.w32;
break;
case 16:
r16 = (uint16_t *) rb;
*r16 = g.w32;
break;
case 32:
r32 = (uint32_t *) rb;
*r32 = g.w32;
break;
case 64:
r64 = (uint64_t *) rb;
*r64 = g.w64;
break;
case 128:
r64 = (uint64_t *) rb;
r64[0] = g.w128[0];
r64[1] = g.w128[1];
break;
}
rb += (w/8);
}
} else if (w == 4) {
r8a = (uint8_t *) ra;
r8 = (uint8_t *) rb;
while (r8 < (uint8_t *) top) {
gf_general_set_random(&g, w, 1);
*r8a = g.w32;
gf_general_set_random(&g, w, 0);
*r8 = g.w32;
r8a++;
r8++;
}
} else {
r32 = (uint32_t *) ra;
for (i = 0; i < size/4; i++) r32[i] = MOA_Random_W(w, 1);
r32 = (uint32_t *) rb;
for (i = 0; i < size/4; i++) r32[i] = MOA_Random_W(w, 0);
}
}
int main(int argc, char **argv)
{
int k, w, i, m, iterations, bufsize;
int *matrix;
char **data, **coding, **old_values;
int *erasures, *erased;
uint32_t seed;
double t = 0, total_time = 0;
gf_t *gf = NULL;
if (argc < 8) usage(NULL);
if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
if (sscanf(argv[2], "%d", &m) == 0 || m <= 0) usage("Bad m");
if (sscanf(argv[3], "%d", &w) == 0 || (w != 8 && w != 16 && w != 32)) usage("Bad w");
if (sscanf(argv[4], "%d", &seed) == 0) usage("Bad seed");
if (sscanf(argv[5], "%d", &iterations) == 0) usage("Bad iterations");
if (sscanf(argv[6], "%d", &bufsize) == 0) usage("Bad bufsize");
if (w <= 16 && k + m > (1 << w)) usage("k + m is too big");
MOA_Seed(seed);
gf = get_gf(w, argc, argv, 7);
if (gf == NULL) {
usage("Invalid arguments given for GF!\n");
}
galois_change_technique(gf, w);
matrix = reed_sol_vandermonde_coding_matrix(k, m, w);
printf("<HTML><TITLE>reed_sol_time_gf");
for (i = 1; i < argc; i++) printf(" %s", argv[i]);
printf("</TITLE>\n");
printf("<h3>reed_sol_time_gf");
for (i = 1; i < argc; i++) printf(" %s", argv[i]);
printf("</h3>\n");
printf("<pre>\n");
printf("Last m rows of the generator matrix (G^T):\n\n");
jerasure_print_matrix(matrix, m, k, w,NULL);
printf("\n");
data = talloc(char *, k);
for (i = 0; i < k; i++) {
data[i] = talloc(char, bufsize);
MOA_Fill_Random_Region(data[i], bufsize);
}
coding = talloc(char *, m);
old_values = talloc(char *, m);
for (i = 0; i < m; i++) {
coding[i] = talloc(char, bufsize);
old_values[i] = talloc(char, bufsize);
}
for (i = 0; i < iterations; i++) {
t = timing_now();
jerasure_matrix_encode(k, m, w, matrix, data, coding, bufsize);
total_time += timing_now() - t;
}
printf("Encode throughput for %d iterations: %.2f MB/s (%.2f sec)\n", iterations, (double)(k*iterations*bufsize/1024/1024) / total_time, total_time);
erasures = talloc(int, (m+1));
erased = talloc(int, (k+m));
for (i = 0; i < m+k; i++) erased[i] = 0;
for (i = 0; i < m; ) {
erasures[i] = ((unsigned int)MOA_Random_W(w, 1))%(k+m);
if (erased[erasures[i]] == 0) {
erased[erasures[i]] = 1;
memcpy(old_values[i], (erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], bufsize);
bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], bufsize);
i++;
}
}
erasures[i] = -1;
for (i = 0; i < iterations; i++) {
t = timing_now();
jerasure_matrix_decode(k, m, w, matrix, 1, erasures, data, coding, bufsize);
total_time += timing_now() - t;
}
printf("Decode throughput for %d iterations: %.2f MB/s (%.2f sec)\n", iterations, (double)(k*iterations*bufsize/1024/1024) / total_time, total_time);
for (i = 0; i < m; i++) {
if (erasures[i] < k) {
if (memcmp(data[erasures[i]], old_values[i], bufsize)) {
fprintf(stderr, "Decoding failed for %d!\n", erasures[i]);
exit(1);
}
} else {
if (memcmp(coding[erasures[i]-k], old_values[i], bufsize)) {
fprintf(stderr, "Decoding failed for %d!\n", erasures[i]);
exit(1);
}
}
}
return 0;
}
int main(int argc, char **argv)
{
int w, j, i, size, iterations;
gf_t gf;
double timer, elapsed, dnum, num;
uint8_t *ra, *rb, *mult4, *mult8;
uint16_t *ra16, *rb16, *log16, *alog16;
time_t t0;
if (argc != 5) usage(NULL);
if (sscanf(argv[1], "%d", &w) == 0) usage("Bad w\n");
if (w != 4 && w != 8 && w != 16) usage("Bad w\n");
if (sscanf(argv[2], "%ld", &t0) == 0) usage("Bad seed\n");
if (sscanf(argv[3], "%d", &size) == 0) usage("Bad #elts\n");
if (sscanf(argv[4], "%d", &iterations) == 0) usage("Bad iterations\n");
if (t0 == -1) t0 = time(0);
MOA_Seed(t0);
num = size;
gf_init_easy(&gf, w);
printf("Seed: %ld\n", t0);
if (w == 4 || w == 8) {
ra = (uint8_t *) malloc(size);
rb = (uint8_t *) malloc(size);
if (ra == NULL || rb == NULL) { perror("malloc"); exit(1); }
} else if (w == 16) {
ra16 = (uint16_t *) malloc(size*2);
rb16 = (uint16_t *) malloc(size*2);
if (ra16 == NULL || rb16 == NULL) { perror("malloc"); exit(1); }
}
if (w == 4) {
mult4 = gf_w4_get_mult_table(&gf);
if (mult4 == NULL) {
printf("Couldn't get inline multiplication table.\n");
exit(1);
}
elapsed = 0;
dnum = 0;
for (i = 0; i < iterations; i++) {
for (j = 0; j < size; j++) {
ra[j] = MOA_Random_W(w, 1);
rb[j] = MOA_Random_W(w, 1);
}
timer_start(&timer);
for (j = 0; j < size; j++) {
ra[j] = GF_W4_INLINE_MULTDIV(mult4, ra[j], rb[j]);
}
dnum += num;
elapsed += timer_split(&timer);
}
printf("Inline mult: %10.6lf s Mops: %10.3lf %10.3lf Mega-ops/s\n",
elapsed, dnum/1024.0/1024.0, dnum/1024.0/1024.0/elapsed);
}
if (w == 8) {
mult8 = gf_w8_get_mult_table(&gf);
if (mult8 == NULL) {
printf("Couldn't get inline multiplication table.\n");
exit(1);
}
elapsed = 0;
dnum = 0;
for (i = 0; i < iterations; i++) {
for (j = 0; j < size; j++) {
ra[j] = MOA_Random_W(w, 1);
rb[j] = MOA_Random_W(w, 1);
}
timer_start(&timer);
for (j = 0; j < size; j++) {
ra[j] = GF_W8_INLINE_MULTDIV(mult8, ra[j], rb[j]);
}
dnum += num;
elapsed += timer_split(&timer);
}
printf("Inline mult: %10.6lf s Mops: %10.3lf %10.3lf Mega-ops/s\n",
elapsed, dnum/1024.0/1024.0, dnum/1024.0/1024.0/elapsed);
}
if (w == 16) {
log16 = gf_w16_get_log_table(&gf);
alog16 = gf_w16_get_mult_alog_table(&gf);
if (log16 == NULL) {
printf("Couldn't get inline multiplication table.\n");
exit(1);
}
elapsed = 0;
dnum = 0;
for (i = 0; i < iterations; i++) {
for (j = 0; j < size; j++) {
ra16[j] = MOA_Random_W(w, 1);
rb16[j] = MOA_Random_W(w, 1);
}
timer_start(&timer);
for (j = 0; j < size; j++) {
ra16[j] = GF_W16_INLINE_MULT(log16, alog16, ra16[j], rb16[j]);
}
dnum += num;
elapsed += timer_split(&timer);
}
printf("Inline mult: %10.6lf s Mops: %10.3lf %10.3lf Mega-ops/s\n",
elapsed, dnum/1024.0/1024.0, dnum/1024.0/1024.0/elapsed);
}
}
int main(int argc, char **argv)
{
long l;
int k, w, i, j, m;
int *matrix;
char **data, **coding, **dcopy, **ccopy;
unsigned char uc;
int *erasures, *erased;
int *decoding_matrix, *dm_ids;
uint32_t seed;
if (argc != 5) usage(NULL);
if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
if (sscanf(argv[2], "%d", &m) == 0 || m <= 0) usage("Bad m");
if (sscanf(argv[3], "%d", &w) == 0 || (w != 8 && w != 16 && w != 32)) usage("Bad w");
if (sscanf(argv[4], "%u", &seed) == 0) usage("Bad seed");
if (w <= 16 && k + m > (1 << w)) usage("k + m is too big");
matrix = reed_sol_vandermonde_coding_matrix(k, m, w);
printf("<HTML><TITLE>reed_sol_01 %d %d %d %d</title>\n", k, m, w, seed);
printf("<h3>reed_sol_01 %d %d %d %d</h3>\n", k, m, w, seed);
printf("<pre>\n");
printf("Last m rows of the generator Matrix (G^T):\n\n");
jerasure_print_matrix(matrix, m, k, w);
printf("\n");
MOA_Seed(seed);
data = talloc(char *, k);
dcopy = talloc(char *, k);
for (i = 0; i < k; i++) {
data[i] = talloc(char, sizeof(long));
dcopy[i] = talloc(char, sizeof(long));
for (j = 0; j < sizeof(long); j++) {
uc = MOA_Random_W(8, 1);
data[i][j] = (char) uc;
}
memcpy(dcopy[i], data[i], sizeof(long));
}
coding = talloc(char *, m);
ccopy = talloc(char *, m);
for (i = 0; i < m; i++) {
coding[i] = talloc(char, sizeof(long));
ccopy[i] = talloc(char, sizeof(long));
}
jerasure_matrix_encode(k, m, w, matrix, data, coding, sizeof(long));
for (i = 0; i < m; i++) {
memcpy(ccopy[i], coding[i], sizeof(long));
}
printf("Encoding Complete:\n\n");
print_data_and_coding(k, m, w, sizeof(long), data, coding);
erasures = talloc(int, (m+1));
erased = talloc(int, (k+m));
for (i = 0; i < m+k; i++) erased[i] = 0;
l = 0;
for (i = 0; i < m; ) {
erasures[i] = MOA_Random_W(31, 0)%(k+m);
if (erased[erasures[i]] == 0) {
erased[erasures[i]] = 1;
memcpy((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], &l, sizeof(long));
i++;
}
}
erasures[i] = -1;
printf("Erased %d random devices:\n\n", m);
print_data_and_coding(k, m, w, sizeof(long), data, coding);
i = jerasure_matrix_decode(k, m, w, matrix, 1, erasures, data, coding, sizeof(long));
printf("State of the system after decoding:\n\n");
print_data_and_coding(k, m, w, sizeof(long), data, coding);
for (i = 0; i < k; i++) if (memcmp(data[i], dcopy[i], sizeof(long)) != 0) {
printf("ERROR: D%x after decoding does not match its state before decoding!<br>\n", i);
}
for (i = 0; i < m; i++) if (memcmp(coding[i], ccopy[i], sizeof(long)) != 0) {
printf("ERROR: C%x after decoding does not match its state before decoding!<br>\n", i);
}
return 0;
}
int main(int argc, char **argv)
{
long l;
int k, w, i, j, m;
int *matrix;
char **data, **coding, **old_values;
int *erasures, *erased;
int *decoding_matrix, *dm_ids;
gf_t *gf = NULL;
uint32_t seed;
if (argc < 6) usage("Not enough command line arguments");
if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
if (sscanf(argv[2], "%d", &m) == 0 || m <= 0) usage("Bad m");
if (sscanf(argv[3], "%d", &w) == 0 || (w != 8 && w != 16 && w != 32)) usage("Bad w");
if (sscanf(argv[4], "%d", &seed) == 0) usage("Bad seed");
if (w <= 16 && k + m > (1 << w)) usage("k + m is too big");
MOA_Seed(seed);
gf = get_gf(w, argc, argv, 5);
if (gf == NULL) {
usage("Invalid arguments given for GF!\n");
}
galois_change_technique(gf, w);
matrix = reed_sol_vandermonde_coding_matrix(k, m, w);
printf("<HTML><TITLE>reed_sol_test_gf");
for (i = 1; i < argc; i++) printf(" %s", argv[i]);
printf("</TITLE>\n");
printf("<h3>reed_sol_test_gf");
for (i = 1; i < argc; i++) printf(" %s", argv[i]);
printf("</h3>\n");
printf("<pre>\n");
printf("Last m rows of the generator matrix (G^T):\n\n");
jerasure_print_matrix(matrix, m, k, w);
printf("\n");
data = talloc(char *, k);
for (i = 0; i < k; i++) {
data[i] = talloc(char, BUFSIZE);
MOA_Fill_Random_Region(data[i], BUFSIZE);
}
coding = talloc(char *, m);
old_values = talloc(char *, m);
for (i = 0; i < m; i++) {
coding[i] = talloc(char, BUFSIZE);
old_values[i] = talloc(char, BUFSIZE);
}
jerasure_matrix_encode(k, m, w, matrix, data, coding, BUFSIZE);
erasures = talloc(int, (m+1));
erased = talloc(int, (k+m));
for (i = 0; i < m+k; i++) erased[i] = 0;
l = 0;
for (i = 0; i < m; ) {
erasures[i] = ((unsigned int)MOA_Random_W(w,1))%(k+m);
if (erased[erasures[i]] == 0) {
erased[erasures[i]] = 1;
memcpy(old_values[i], (erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], BUFSIZE);
bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], BUFSIZE);
i++;
}
}
erasures[i] = -1;
i = jerasure_matrix_decode(k, m, w, matrix, 1, erasures, data, coding, BUFSIZE);
for (i = 0; i < m; i++) {
if (erasures[i] < k) {
if (memcmp(data[erasures[i]], old_values[i], BUFSIZE)) {
fprintf(stderr, "Decoding failed for %d!\n", erasures[i]);
exit(1);
}
} else {
if (memcmp(coding[erasures[i]-k], old_values[i], BUFSIZE)) {
fprintf(stderr, "Decoding failed for %d!\n", erasures[i]);
exit(1);
}
}
}
printf("Encoding and decoding were both successful.\n");
return 0;
}
int main(int argc, char **argv)
{
int k, m, w, size;
int i, j;
int *matrix;
char **data, **coding;
int *erasures, *erased;
int *decoding_matrix, *dm_ids;
uint32_t seed;
if (argc != 6) usage(NULL);
if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
if (sscanf(argv[2], "%d", &m) == 0 || m <= 0) usage("Bad m");
if (sscanf(argv[3], "%d", &w) == 0 || (w != 8 && w != 16 && w != 32)) usage("Bad w");
if (w < 32 && k + m > (1 << w)) usage("k + m must be <= 2 ^ w");
if (sscanf(argv[4], "%d", &size) == 0 || size % sizeof(long) != 0)
usage("size must be multiple of sizeof(long)");
if (sscanf(argv[5], "%d", &seed) == 0) usage("Bad seed");
matrix = talloc(int, m*k);
for (i = 0; i < m; i++) {
for (j = 0; j < k; j++) {
matrix[i*k+j] = galois_single_divide(1, i ^ (m + j), w);
}
}
printf("<HTML><TITLE>jerasure_05");
for (i = 1; i < argc; i++) printf(" %s", argv[i]);
printf("</TITLE>\n");
printf("<h3>jerasure_05");
for (i = 1; i < argc; i++) printf(" %s", argv[i]);
printf("</h3>\n");
printf("<pre>\n");
printf("The Coding Matrix (the last m rows of the Generator Matrix G^T):\n\n");
jerasure_print_matrix(matrix, m, k, w);
printf("\n");
MOA_Seed(seed);
data = talloc(char *, k);
for (i = 0; i < k; i++) {
data[i] = talloc(char, size);
MOA_Fill_Random_Region(data[i], size);
}
coding = talloc(char *, m);
for (i = 0; i < m; i++) {
coding[i] = talloc(char, size);
}
jerasure_matrix_encode(k, m, w, matrix, data, coding, size);
printf("Encoding Complete:\n\n");
print_data_and_coding(k, m, w, size, data, coding);
erasures = talloc(int, (m+1));
erased = talloc(int, (k+m));
for (i = 0; i < m+k; i++) erased[i] = 0;
for (i = 0; i < m; ) {
erasures[i] = (MOA_Random_W(w, 1))%(k+m);
if (erased[erasures[i]] == 0) {
erased[erasures[i]] = 1;
bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], size);
i++;
}
}
erasures[i] = -1;
printf("Erased %d random devices:\n\n", m);
print_data_and_coding(k, m, w, size, data, coding);
i = jerasure_matrix_decode(k, m, w, matrix, 0, erasures, data, coding, size);
printf("State of the system after decoding:\n\n");
print_data_and_coding(k, m, w, size, data, coding);
decoding_matrix = talloc(int, k*k);
dm_ids = talloc(int, k);
for (i = 0; i < m; i++) erased[i] = 1;
for (; i < k+m; i++) erased[i] = 0;
jerasure_make_decoding_matrix(k, m, w, matrix, erased, decoding_matrix, dm_ids);
printf("Suppose we erase the first %d devices. Here is the decoding matrix:\n\n", m);
jerasure_print_matrix(decoding_matrix, k, k, w);
printf("\n");
printf("And dm_ids:\n\n");
jerasure_print_matrix(dm_ids, 1, k, w);
bzero(data[0], size);
jerasure_matrix_dotprod(k, w, decoding_matrix, dm_ids, 0, data, coding, size);
printf("\nAfter calling jerasure_matrix_dotprod, we calculate the value of device #0 to be:\n\n");
printf("D0 :");
for(i=0;i< size; i+=(w/8)) {
printf(" ");
for(j=0;j < w/8;j++){
printf("%02x", (unsigned char)data[0][i+j]);
}
}
printf("\n\n");
return 0;
}
