int main(int argc, char **argv)
{
long l;
int k, w, i, j, m;
int *matrix;
char **data, **coding;
int *erasures, *erased;
int *decoding_matrix, *dm_ids;
if (argc != 3) usage(NULL);
if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
if (sscanf(argv[2], "%d", &w) == 0 || (w != 8 && w != 16 && w != 32)) usage("Bad w");
m = 2;
if (w <= 16 && k + m > (1 << w)) usage("k + m is too big");
matrix = reed_sol_r6_coding_matrix(k, w);
printf("Last 2 rows of the Distribution Matrix:\n\n");
jerasure_print_matrix(matrix, m, k, w);
printf("\n");
srand48(0);
data = talloc(char *, k);
for (i = 0; i < k; i++) {
data[i] = talloc(char, sizeof(long));
l = lrand48();
memcpy(data[i], &l, sizeof(long));
}
coding = talloc(char *, m);
for (i = 0; i < m; i++) {
coding[i] = talloc(char, sizeof(long));
}
reed_sol_r6_encode(k, w, data, coding, 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] = lrand48()%(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);
return 0;
}
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)
{
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)
{
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)
{
gdata l;
int k, w, i, j, m;
int *matrix;
char **data, **coding;
int *erasures, *erased;
int *decoding_matrix, *dm_ids;
struct jerasure_context *ctx;
if (argc != 4) 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 <= 16 && k + m > (1 << w)) usage("k + m is too big");
ctx = jerasure_make_context(w);
matrix = reed_sol_vandermonde_coding_matrix(ctx, k, m);
printf("Last m rows of the Distribution Matrix:\n\n");
jerasure_print_matrix(matrix, m, k, w);
printf("\n");
srand48(0);
data = talloc(char *, k);
for (i = 0; i < k; i++) {
data[i] = talloc(char, sizeof(gdata));
fillrand(data[i], sizeof(gdata));
}
coding = talloc(char *, m);
for (i = 0; i < m; i++) {
coding[i] = talloc(char, sizeof(gdata));
}
jerasure_matrix_encode(ctx, k, m, matrix, data, coding, sizeof(gdata));
printf("Encoding Complete:\n\n");
print_data_and_coding_1(k, m, w, sizeof(gdata), 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] = lrand48()%(k+m);
if (erased[erasures[i]] == 0) {
erased[erasures[i]] = 1;
memcpy((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], &l, sizeof(gdata));
i++;
}
}
erasures[i] = -1;
printf("Erased %d random devices:\n\n", m);
print_data_and_coding_1(k, m, w, sizeof(gdata), data, coding);
i = jerasure_matrix_decode(ctx, k, m, matrix, 1, erasures, data, coding, sizeof(gdata));
printf("State of the system after decoding:\n\n");
print_data_and_coding_1(k, m, w, sizeof(gdata), data, coding);
/* free data to avoid false positives for leak testing */
free(erased);
free(erasures);
for (i = 0; i < m; i++) {
free(coding[i]);
}
free(coding);
for (i = 0; i < k; i++) {
free(data[i]);
}
free(data);
free(matrix);
jerasure_release_context(ctx);
return 0;
}
int main (int argc, char **argv) {
FILE *fp; // File pointer
char *dummy;
int err;
/* Jerasure arguments */
char **data;
char **coding;
int *erasures;
int *erased;
int *matrix;
int *bitmatrix;
/* Parameters */
int k, m, w, packetsize, buffersize;
enum Coding_Technique tech;
char *c_tech;
int i, j; // loop control variables
int blocksize; // size of individual files
int origsize; // size of file before padding
int total; // used to write data, not padding to file
struct stat status; // used to find size of individual files
int numerased; // number of erased files
/* Used to recreate file names */
char *temp;
char *cs1, *cs2, *extension;
char *fname;
int md;
char *curdir;
/* Used to time decoding */
struct timeval t1, t2, t3, t4;
struct timezone tz;
double tsec;
double totalsec;
signal(SIGQUIT, ctrl_bs_handler);
matrix = NULL;
bitmatrix = NULL;
totalsec = 0.0;
blocksize = -1;
/* Start timing */
gettimeofday(&t1, &tz);
/* Error checking parameters */
if (argc != 2) {
fprintf(stderr, "usage: inputfile\n");
exit(0);
}
curdir = (char *)malloc(sizeof(char)*100);
dummy = getcwd(curdir, 100);
/* Begin recreation of file names */
cs1 = (char*)malloc(sizeof(char)*strlen(argv[1]));
cs2 = strrchr(argv[1], '/');
if (cs2 != NULL) {
cs2++;
strcpy(cs1, cs2);
}
else {
strcpy(cs1, argv[1]);
}
cs2 = strchr(cs1, '.');
if (cs2 != NULL) {
extension = strdup(cs2);
*cs2 = '\0';
} else {
extension = strdup("");
}
fname = (char *)malloc(sizeof(char*)*(100+strlen(argv[1])+10));
/* Read in parameters from metadata file */
sprintf(fname, "%s/Coding/%s_meta.txt", curdir, cs1);
fp = fopen(fname, "rb");
if (fp == NULL) {
fprintf(stderr, "Error: no metadata file %s\n", fname);
exit(1);
}
temp = (char *)malloc(sizeof(char)*(strlen(argv[1])+10));
err = fscanf(fp, "%s", temp);
if (fscanf(fp, "%d", &origsize) != 1) {
fprintf(stderr, "Original size is not valid\n");
exit(0);
}
if (fscanf(fp, "%d %d %d %d %d", &k, &m, &w, &packetsize, &buffersize) != 5) {
fprintf(stderr, "Parameters are not correct\n");
exit(0);
}
c_tech = (char *)malloc(sizeof(char)*(strlen(argv[1])+10));
err = fscanf(fp, "%s", c_tech);
err = fscanf(fp, "%d", &tech);
method = tech;
err = fscanf(fp, "%d", &readins);
fclose(fp);
/* Allocate memory */
erased = (int *)malloc(sizeof(int)*(k+m));
for (i = 0; i < k+m; i++)
erased[i] = 0;
erasures = (int *)malloc(sizeof(int)*(k+m));
data = (char **)malloc(sizeof(char *)*k);
coding = (char **)malloc(sizeof(char *)*m);
if (buffersize != origsize) {
for (i = 0; i < k; i++) {
data[i] = (char *)malloc(sizeof(char)*(buffersize/k));
}
for (i = 0; i < m; i++) {
coding[i] = (char *)malloc(sizeof(char)*(buffersize/k));
}
blocksize = buffersize/k;
}
sprintf(temp, "%d", k);
md = strlen(temp);
gettimeofday(&t3, &tz);
/* Create coding matrix or bitmatrix */
switch(tech) {
case No_Coding:
case RDP:
case EVENODD:
break;
case Reed_Sol_Van:
matrix = reed_sol_vandermonde_coding_matrix(k, m, w);
break;
case Reed_Sol_R6_Op:
matrix = reed_sol_r6_coding_matrix(k, w);
break;
case Cauchy_Orig:
matrix = cauchy_original_coding_matrix(k, m, w);
bitmatrix = jerasure_matrix_to_bitmatrix(k, m, w, matrix);
break;
case Cauchy_Good:
matrix = cauchy_good_general_coding_matrix(k, m, w);
bitmatrix = jerasure_matrix_to_bitmatrix(k, m, w, matrix);
break;
case Liberation:
bitmatrix = liberation_coding_bitmatrix(k, w);
break;
case Blaum_Roth:
bitmatrix = blaum_roth_coding_bitmatrix(k, w);
break;
case Liber8tion:
bitmatrix = liber8tion_coding_bitmatrix(k);
break;
default:
fprintf(stderr, "unsupported coding technique used\n");
break;
}
gettimeofday(&t4, &tz);
tsec = 0.0;
tsec += t4.tv_usec;
tsec -= t3.tv_usec;
tsec /= 1000000.0;
tsec += t4.tv_sec;
tsec -= t3.tv_sec;
totalsec += tsec;
/* Begin decoding process */
total = 0;
n = 1;
while (n <= readins) {
numerased = 0;
/* Open files, check for erasures, read in data/coding */
for (i = 1; i <= k; i++) {
sprintf(fname, "%s/Coding/%s_k%0*d%s", curdir, cs1, md, i, extension);
fp = fopen(fname, "rb");
if (fp == NULL) {
erased[i-1] = 1;
erasures[numerased] = i-1;
numerased++;
//printf("%s failed\n", fname);
}
else {
if (buffersize == origsize) {
stat(fname, &status);
blocksize = status.st_size;
data[i-1] = (char *)malloc(sizeof(char)*blocksize);
err = fread(data[i-1], sizeof(char), blocksize, fp);
}
else {
fseek(fp, blocksize*(n-1), SEEK_SET);
err = fread(data[i-1], sizeof(char), buffersize/k, fp);
}
fclose(fp);
}
}
for (i = 1; i <= m; i++) {
sprintf(fname, "%s/Coding/%s_m%0*d%s", curdir, cs1, md, i, extension);
fp = fopen(fname, "rb");
if (fp == NULL) {
erased[k+(i-1)] = 1;
erasures[numerased] = k+i-1;
numerased++;
//printf("%s failed\n", fname);
}
else {
if (buffersize == origsize) {
stat(fname, &status);
blocksize = status.st_size;
coding[i-1] = (char *)malloc(sizeof(char)*blocksize);
err = fread(coding[i-1], sizeof(char), blocksize, fp);
}
else {
fseek(fp, blocksize*(n-1), SEEK_SET);
err = fread(coding[i-1], sizeof(char), blocksize, fp);
}
fclose(fp);
}
}
/* Finish allocating data/coding if needed */
if (n == 1) {
for (i = 0; i < numerased; i++) {
if (erasures[i] < k) {
data[erasures[i]] = (char *)malloc(sizeof(char)*blocksize);
}
else {
coding[erasures[i]-k] = (char *)malloc(sizeof(char)*blocksize);
}
}
}
erasures[numerased] = -1;
gettimeofday(&t3, &tz);
/* Choose proper decoding method */
if (tech == Reed_Sol_Van || tech == Reed_Sol_R6_Op) {
i = jerasure_matrix_decode(k, m, w, matrix, 1, erasures, data, coding, blocksize);
}
else if (tech == Cauchy_Orig || tech == Cauchy_Good || tech == Liberation || tech == Blaum_Roth || tech == Liber8tion) {
i = jerasure_schedule_decode_lazy(k, m, w, bitmatrix, erasures, data, coding, blocksize, packetsize, 1);
}
else {
fprintf(stderr, "Not a valid coding technique.\n");
exit(0);
}
gettimeofday(&t4, &tz);
/* Exit if decoding was unsuccessful */
if (i == -1) {
fprintf(stderr, "Unsuccessful!\n");
exit(0);
}
/* Create decoded file */
sprintf(fname, "%s/Coding/%s_decoded%s", curdir, cs1, extension);
if (n == 1) {
fp = fopen(fname, "wb");
}
else {
fp = fopen(fname, "ab");
}
for (i = 0; i < k; i++) {
if (total+blocksize <= origsize) {
fwrite(data[i], sizeof(char), blocksize, fp);
total+= blocksize;
}
else {
for (j = 0; j < blocksize; j++) {
if (total < origsize) {
fprintf(fp, "%c", data[i][j]);
total++;
}
else {
break;
}
}
}
}
n++;
fclose(fp);
tsec = 0.0;
tsec += t4.tv_usec;
tsec -= t3.tv_usec;
tsec /= 1000000.0;
tsec += t4.tv_sec;
tsec -= t3.tv_sec;
totalsec += tsec;
}
/* Free allocated memory */
free(cs1);
free(extension);
free(fname);
free(data);
free(coding);
free(erasures);
free(erased);
/* Stop timing and print time */
gettimeofday(&t2, &tz);
tsec = 0;
tsec += t2.tv_usec;
tsec -= t1.tv_usec;
tsec /= 1000000.0;
tsec += t2.tv_sec;
tsec -= t1.tv_sec;
printf("Decoding (MB/sec): %0.10f\n", (origsize/1024/1024)/totalsec);
printf("De_Total (MB/sec): %0.10f\n\n", (origsize/1024/1024)/tsec);
return(0);
}
/*decoder that decoded using only 'k' SRC encoded files */
void Decode_by_reed_sol(){
int *encoder_matrix;
int *total;
int temp_size;
lookupTable *repairChunksTable,*nodePacketData;
char **data,**coding;
int *node2ReadFrom;
int *erasedNodes,*erasure;
int *erasedArray,*erasedstream;
int bytesWritten2File;
int i,j,p;
int extra,q,z,decodeFlag;
int index;
int nodeSurviving;
struct timeval start_mem_time, stop_mem_time;
struct timezone tz;
double total_mem_time;
m = n-k;
encoder_matrix = NULL;
total_mem_time =0.0;
encoder_matrix = reed_sol_vandermonde_coding_matrix(k, m, w);
total = (int*)malloc(sizeof(int)*n);
bytesEachDataStreamWrites2File = (int*)malloc(sizeof(int)*k*f);
repairChunksTable = (lookupTable *)malloc(sizeof(lookupTable)*(f)*(f+1));
data = (char**)malloc(sizeof(char*)*k);
coding = (char**)malloc(sizeof(char*)*m);
nodePacketData = (lookupTable*)malloc(sizeof(lookupTable)*(f+1)*k);
repairChunksTable = (lookupTable*)malloc(sizeof(lookupTable)*(f)*filesUnavailable);
//printf("Lost Files are :\n");
//for(i=0;i<filesUnavailable;i++)
// printf("%d. %s\n",i,fileNamesUnavailable[i]);
node2ReadFrom = (int*)malloc(sizeof(int)*(k));
erasedNodes = (int*)malloc(sizeof(int)*filesUnavailable);
erasure = (int*)malloc(sizeof(int)*(n-k+1));
erasedstream = (int*)malloc(sizeof(int)*(n-k+1));
erasedArray = (int*)malloc(sizeof(int)*(n));
temp_size = size;
for(i=0;i<k*f;i++){
if(temp_size>chunkSize){
bytesEachDataStreamWrites2File[i] = chunkSize;
temp_size = temp_size - chunkSize;
}
else if((temp_size < chunkSize)&&(temp_size != 0)){
bytesEachDataStreamWrites2File[i] = temp_size;
temp_size = 0;
}
else if(temp_size == 0){
bytesEachDataStreamWrites2File[i] = 0;
}
}
for(i=0;i<n;i++)
erasedArray[i] = -1;
// find files lost(or files lost)
j=0;
for(i=0;i<n;i++){
if((nodeIndexUnavailable[i] == 1)){
erasedNodes[j] = i;
j++;
}
}
// -1 indicates available and 1 indicates lost
// pick any k files to read from and assume rest to be erased
j=0;
p=0;
for(i=0;i<n;i++){
if((nodeIndexUnavailable[i] == -1)&&(j<k)){
node2ReadFrom[j] = i;
j++;
}
else{
erasure[p] = i;
erasedstream[p] = i;
p++;
}
}
erasure[p] = -1;
erasedstream[p] = -1;
j=0;
nodeSurviving = 0;
for(j=0;j<k;j++){
for(i = nodeSurviving;i<n;i++){
if(nodeIndexUnavailable[i] == -1){
nodeSurviving = i;
break;
}
}
for(i=0;i<(f+1);i++){
(nodePacketData[i + j*(f+1)].chunkInfo).fileIndex = ((LookupTable[i+nodeSurviving*(f+1)])->chunkInfo).fileIndex;
(nodePacketData[i+ j*(f+1)].chunkInfo).start = ((LookupTable[i+nodeSurviving*(f+1)])->chunkInfo).start;
((nodePacketData[i + j*(f+1)].chunkInfo).Nbytes =((LookupTable[i+nodeSurviving*(f+1)])->chunkInfo).Nbytes);
}
nodeSurviving = nodeSurviving + 1;
}
/*determine number of read-ins */
if (chunkSize > buffersize && buffersize != 0) {
if (chunkSize%buffersize != 0) {
readins = chunkSize/buffersize;
}
else {
readins = chunkSize/buffersize;
}
}
else {
readins = 1;
buffersize = chunkSize;
}
readFileStreams = (FILE**)malloc(sizeof(FILE*)*k);
filedecoded = (FILE**)malloc(sizeof(FILE*));
for(i=0;i<k;i++){
if((readFileStreams[i] = fopen(file2beread[node2ReadFrom[i]],"rb")) == NULL)
printf("Unable to read file \n");
}
filedecoded[0] = fopen(decodedName,"wb");
/*pick any 'k' files to be used for decoding*/
for(i=0;i<f;i++){
for(j=0;j<k;j++){
if(readins == 1)
data[j] = (char*)calloc(chunkSize,sizeof(char));
else
data[j] = (char*)calloc(buffersize,sizeof(char));
}
for(j=0;j<m;j++){
if(readins == 1)
coding[j] = (char*)calloc(chunkSize,sizeof(char));
else
coding[j] = (char*)calloc(buffersize,sizeof(char));
}
for(j=0;j<n;j++)
total[j] = 0;
p=1;
while(p<=readins){
for(j=0;j<k;j++){
fseek(readFileStreams[j],i*chunkSize+(p-1)*buffersize,SEEK_SET);
if((nodePacketData[i + j*(f+1)].chunkInfo).fileIndex < k){
index = (nodePacketData[i + j*(f+1)].chunkInfo).fileIndex;
erasedArray[index] = 1;
if (total[index] < chunkSize && total[index]+buffersize <= chunkSize) {
total[index] += fread(data[index], sizeof(char), buffersize,readFileStreams[j]);
fflush(readFileStreams[j]);
}
else if (total[index] < chunkSize && total[index]+chunkSize > chunkSize) {
extra = fread(data[index], sizeof(char), buffersize, readFileStreams[j]);
fflush(readFileStreams[j]);
for (q = extra; q < buffersize; q++) {
data[index][q] = '0';
}
}
else if (total[index] == chunkSize) {
for (q = 0; q < buffersize; q++) {
data[index][q] = '0';
}
}
}
else{
index = (nodePacketData[i + j*(f+1)].chunkInfo).fileIndex-k;
erasedArray[index+k] = 1;
if (total[index+k] < chunkSize && total[index+k]+buffersize <= chunkSize) {
total[index+k] += fread(coding[index], sizeof(char), buffersize,readFileStreams[j]);
fflush(readFileStreams[j]);
}
else if (total[index+k] < chunkSize && total[index+k]+chunkSize > chunkSize) {
extra = fread(coding[index], sizeof(char), buffersize, readFileStreams[j]);
fflush(readFileStreams[j]);
for (q = extra; q < buffersize; q++) {
coding[index][q] = '0';
}
}
else if (total[index+k] == chunkSize) {
for (q = 0; q < buffersize; q++) {
coding[index][q] = '0';
}
}
}
}
z=0;
for(j=0;j<n;j++){
if(erasedArray[j] == -1){
erasedstream[z] = j;
z++;
}
}
erasedstream[z] = -1;
z = 0;
gettimeofday(&start_mem_time, &tz);
if((decodeFlag = jerasure_matrix_decode(k, m, w, encoder_matrix, 1, erasedstream, data, coding, buffersize))==-1){
printf("Decoding Failed\n");
exit(0);
}
gettimeofday(&stop_mem_time, &tz);
mem_time = 0.0;
mem_time += stop_mem_time.tv_usec;
mem_time -= start_mem_time.tv_usec;
mem_time /= 1000000.0;
mem_time += stop_mem_time.tv_sec;
mem_time -= start_mem_time.tv_sec;
total_mem_time += mem_time;
for(j=0;j<n;j++)
erasedArray[j] = -1;
for(j=0;j<k;j++){
if(bytesEachDataStreamWrites2File[i*k+j]>0){
fseek(filedecoded[0],(i*k+j)*chunkSize+(p-1)*buffersize,SEEK_SET);
if (bytesEachDataStreamWrites2File[i*k+j] >= buffersize) {
bytesEachDataStreamWrites2File[i*k+j] -= fwrite(data[j], sizeof(char), buffersize,filedecoded[0]);
bytesWritten2File += buffersize;
fflush(filedecoded[0]);
}
else if (bytesEachDataStreamWrites2File[i*k+j] < buffersize) {
for(q=0;q<(bytesEachDataStreamWrites2File[i*k+j]);q++){
fprintf(filedecoded[0],"%c",data[j][q]);
}
bytesWritten2File = bytesWritten2File + q;
bytesEachDataStreamWrites2File[i*k+j] -= q;
if(bytesWritten2File == size)
break;
}
}
}
p++;
if(bytesWritten2File == size)
break;
}
for(j=0;j<k;j++)
free(data[j]);
for(j=0;j<m;j++)
free(coding[j]);
if(bytesWritten2File == size)
break;
}
fclose(filedecoded[0]);
for(i=0;i<k;i++)
fclose(readFileStreams[i]);
printf("Decoding Rate (file size /totaltime) is %0.10f\n",(((float)size/1024)/1024)/(total_mem_time));
}
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;
}
