/** * Update state by subtracting inval. * Emit the previous state as outval. * If new state > 0, emit a new state. */ void *add( void *hnd, c4snet_data_t *state, c4snet_data_t *inval) { int int_state, int_newstate, int_inval; c4snet_data_t *data_newstate, *data_output; int_state = *(int *) C4SNetGetData(state); int_inval = *(int *) C4SNetGetData(inval); /* update state */ int_newstate = int_state - int_inval; if (int_newstate > 0) { data_newstate = C4SNetCreate(CTYPE_int, 1, &int_newstate); C4SNetOut( hnd, 1, data_newstate); } /* emit old state as output */ data_output = C4SNetCreate(CTYPE_int, 1, &int_state); C4SNetOut( hnd, 2, data_output); C4SNetFree(state); C4SNetFree(inval); return( hnd); }
/** * Update state by adding inval and emitting new state and old state as output * if new state >= MAXVAL, a trigger is emitted instead of a new state. */ void *compute( void *hnd, c4snet_data_t *state, c4snet_data_t *inval) { int int_state, int_newstate, int_inval; c4snet_data_t *data_newstate, *data_output; int_state = *(int *) C4SNetGetData(state); int_inval = *(int *) C4SNetGetData(inval); /* emit outval */ data_output = C4SNetCreate(CTYPE_int, 1, &int_state); C4SNetOut( hnd, 1, data_output); /* update state */ int_newstate = int_state + int_inval; if (int_newstate < MAXVAL) { /* emit state */ data_newstate = C4SNetCreate(CTYPE_int, 1, &int_newstate); C4SNetOut( hnd, 2, data_newstate); } else { /* emit trigger */ data_newstate = C4SNetCreate(CTYPE_int, 1, &int_newstate); C4SNetOut( hnd, 3, data_newstate); } C4SNetFree(state); C4SNetFree(inval); return( hnd); }
void *merge(void *hnd, c4snet_data_t *OutFile, c4snet_data_t *Result, int X, c4snet_data_t *Out, int N, int B, int K, int J, int I) { const int P = N / B; if (verbose) { printf("%s: %p, %p, X=%d, %p, N=%d, B=%d, (%d, %d, %d)\n", __func__, OutFile, Result, X, Out, N, B, K, J, I); } if (compute) { c4snet_data_t **result = C4SNetGetData(Result); assert(result[J + I * P] == NULL); result[J + I * P] = Out; } if (X > 1) { C4SNetOut(hnd, 1, OutFile, Result, X - 1); } else if (compute) { struct timespec end; if (clock_gettime(CLOCK_REALTIME, &end)) { pexit("clock_gettime"); } printf("Time for size %d x %d : %lf sec\n", N, N, delta_time(begin, end)); write_matrix(Result, N, B, OutFile); C4SNetOut(hnd, 2, C4SNetCreate(CTYPE_char, 5, "Done.")); C4SNetFree(OutFile); C4SNetFree(Result); } return hnd; }
void * decompose (void *hnd, c4snet_data_t *InFile, c4snet_data_t *OutFile, int a_size, int bs) { int p, i, j; double *array; tile *atiles, *ltiles; char *infile; if (bs <= 0) { fprintf (stderr, "A block size must be greater than 0\n"); exit (1); } if (a_size <= 0) { fprintf (stderr, "The dimension of matrix must be greater than 0\n"); exit (1); } if (a_size % bs) { fprintf(stderr, "matrix size %d is not a multiple of the block size %d\n", a_size, bs); exit(1); } p = a_size / bs; /* Get the input filename as a string. */ infile = chars_to_string(InFile); outfile = chars_to_string(OutFile); C4SNetFree(InFile); C4SNetFree(OutFile); array = SNetMemAlloc(a_size * a_size * sizeof(double)); read_matrix(a_size, array, infile); free(infile); if (clock_gettime(CLOCK_REALTIME, &begin)) { pexit("clock_gettime"); } atiles = (tile *) malloc (sizeof (tile) * p * p); ltiles = (tile *) malloc (sizeof (tile) * p * p); memset (atiles, 0, sizeof (tile) * p * p); memset (ltiles, 0, sizeof (tile) * p * p); for (i = 0; i < p; i++) for (j = 0; j <= i; j++) { atiles[j * p + i] = (double *) malloc (sizeof (double) * bs * bs); ltiles[j * p + i] = (double *) malloc (sizeof (double) * bs * bs); int ai, aj, ti, tj; for (ai = i * bs, ti = 0; ti < bs; ai++, ti++) for (aj = j * bs, tj = 0; tj < bs; aj++, tj++) atiles[j * p + i][tj * bs + ti] = array[aj * a_size + ai]; } C4SNetOut (hnd, 1, C4SNetCreate (CTYPE_char, sizeof (void *), &atiles), C4SNetCreate (CTYPE_char, sizeof (void *), <iles), bs, p, 0); free(array); return hnd; }
void *finalP(void *hnd, c4snet_data_t *sd, c4snet_data_t *sk, int c) { char *D = (char *) C4SNetGetData(sd); char E[8]; Permute( E, D, FinalPermuteMap, 8 ); // printbyte(E); C4SNetOut(hnd, 1, C4SNetCreate(CTYPE_char, 8, &E[0])); C4SNetFree(sd); C4SNetFree(sk); return hnd; }
void *initP(void *hnd, c4snet_data_t *spt, c4snet_data_t *skey) { char *pt = (char *) C4SNetGetData(spt); char *key = (char *) C4SNetGetData(skey); char K[7]; char D[8]; Permute( K, key, KeyPermuteMap, 7 ); Permute( D, pt, InitialPermuteMap, 8 ); C4SNetOut(hnd, 1, C4SNetCreate(CTYPE_char, 8, &D[0]), C4SNetCreate(CTYPE_char, 7, &K[0]), 0); C4SNetFree(spt); C4SNetFree(skey); return hnd; }
void *finalP(void *hnd, c4snet_data_t *sd, c4snet_data_t *sk, int c, int size) { char *D = (char *) C4SNetGetData(sd); int i; char *E = (char *) SCCMallocPtr(8 * size); for (i = 0; i < size; i++) Permute( &E[i * 8], &D[i * 8], FinalPermuteMap, 8 ); //printbyte(E, size); C4SNetOut(hnd, 1, C4SNetCreate(CTYPE_char, size, &E[0]), size); C4SNetFree(sd); C4SNetFree(sk); //SCCFreePtr(E); return hnd; }
static void write_matrix(c4snet_data_t *Result, int N, int B, c4snet_data_t *OutFile) { const int P = N / B; int r, c, r_b, c_b; c4snet_data_t **result = C4SNetGetData(Result); char *outf = C4SNetGetString(OutFile); FILE *fp = xfopen(outf, "w"); for (r = 0; r < P; ++r) { for (r_b = 0; r_b < B; ++r_b) { for (c = 0; c <= r; ++c) { c4snet_data_t *T = result[r + c * P]; tile_t tmp = C4SNetGetData(T); for (c_b = 0; (r != c) ? (c_b < B) : (c_b <= r_b); ++c_b) { double a = tmp[r_b + c_b * B]; char buf[40]; fnum(a, buf); fputs(buf, fp); } } fprintf(fp, "\n"); } } xfclose(fp); free(outf); for (r = 0; r < P; ++r) { for (c = 0; c <= r; ++c) { c4snet_data_t *Out = result[r + c * P]; C4SNetFree(Out); } } }
void *split( void *hnd, c4snet_data_t *A, int A_width, int A_height, int nodes) { int i, first, last, block; int *new_array; c4snet_data_t *new_data; int *array = C4SNetGetData(A); block = A_height / nodes; first = 0; last = first + block - 1; for (i = 0; i < nodes - 1; i++) { new_data = C4SNetAlloc(CTYPE_int, A_width * (last - first + 1), (void **) &new_array); memcpy(new_array, (array + A_width * first), sizeof(int) * A_width * (last - first + 1)); C4SNetOut( hnd, 1, new_data, A_width, A_height, i, first, last); first = last + 1; last += block; } last = A_height - 1; new_data = C4SNetAlloc(CTYPE_int, A_width * (last - first + 1), (void **) &new_array); memcpy(new_array, (array + A_width * first), sizeof(int) * A_width * (last - first + 1)); C4SNetOut(hnd, 1, new_data, A_width, A_height, i, first, last); C4SNetFree(A); return hnd; }
void *initP(void *hnd, c4snet_data_t *spt, c4snet_data_t *skey, int size) { char *pt = (char *) C4SNetGetData(spt); char *key = (char *) C4SNetGetData(skey); char *K = (char *) SCCMallocPtr(size * 7); char *D = (char *) SCCMallocPtr(size * 8); int i; for (i = 0; i < size; i++) { Permute( &K[i * 7], key, KeyPermuteMap, 7 ); Permute( &D[i * 8], pt, InitialPermuteMap, 8 ); } C4SNetOut(hnd, 1, C4SNetCreate(CTYPE_char, 8 * size, &D[0]), C4SNetCreate(CTYPE_char, 7 * size, &K[0]), 0, size); C4SNetFree(spt); C4SNetFree(skey); SCCFreePtr (K); SCCFreePtr (D); return hnd; }
void *add( void *hnd, c4snet_data_t *n, c4snet_data_t *w) { int int_n = *(int *) C4SNetGetData(n); int int_w = *(int *) C4SNetGetData(w); C4SNetFree(n); C4SNetFree(w); int i, s; for (s = int_n, i = 0; i <= int_w; ++i) { s += int_n; __asm__ __volatile__ (""); } C4SNetOut(hnd, 1, C4SNetCreate(CTYPE_int, 1, &int_n), C4SNetCreate(CTYPE_int, 1, &int_w)); return hnd; }
void *condif( void *hnd, c4snet_data_t *p) { bool bool_p = *(bool *) C4SNetGetData(p); if (bool_p) C4SNetOut(hnd, 1, 0); else C4SNetOut(hnd, 2, 0); C4SNetFree(p); return hnd; }
void *algorithm( void *hnd, c4snet_data_t *password, c4snet_data_t *salt, c4snet_data_t *dictionary, int dictionary_size) { struct crypt_data cdata; char *pw, *slt, *dict, *result; bool found = false; int i, j; cdata.initialized = 0; pw = C4SNetGetData(password); slt = C4SNetGetData(salt); dict = C4SNetGetData(dictionary); for (i = 0, j = 0; i < dictionary_size; i++) { result = crypt_r(&dict[j], slt, &cdata); if (!strcmp(result, pw)) { C4SNetOut(hnd, 1, C4SNetCreate(CTYPE_char, strlen(&dict[j]), &dict[j])); found = true; break; } else { j += 1 + strlen(&dict[j]); } } if (!found) { C4SNetOut(hnd, 2, 0); } C4SNetFree(password); C4SNetFree(salt); C4SNetFree(dictionary); return hnd; }
/* Do the InitialFactorization from input tile Fac to output tile Tri. */ void *facto(void *hnd, c4snet_data_t *Fac, int N, int B, int K) { int j; const int P = N / B; c4snet_data_t *Tri; if (verbose) { printf("%s: %p, N=%d, B=%d, (%d, , )\n", __func__, Fac, N, B, K); } if (compute) { tile_t A = (tile_t) C4SNetGetData(Fac); void *tile_ptr; c4snet_data_t *tile = C4SNetAlloc(CTYPE_double, B * B, &tile_ptr); tile_t L = (tile_t) tile_ptr; int k_b, j_b, j_bb, i_b; memset(L, 0, B * B * sizeof(double)); for (k_b = 0; k_b < B; ++k_b) { if (A[k_b + k_b * B] <= 0) { fprintf(stderr, "Not a symmetric positive definite (SPD) matrix\n"); fprintf(stderr, "K = %d, k_b = %d, B = %d, A[k_b + k_b * B] = %f\n", K, k_b, B, A[k_b + k_b * B]); exit(1); } L[k_b + k_b * B] = sqrt(A[k_b + k_b * B]); for (j_b = k_b + 1; j_b < B; ++j_b) { L[j_b + k_b * B] = A[j_b + k_b * B] / L[k_b + k_b * B]; } for (j_bb = k_b + 1; j_bb < B; ++j_bb) { for (i_b = j_bb; i_b < B; ++i_b) { A[i_b + j_bb * B] -= L[i_b + k_b * B] * L[j_bb + k_b * B]; } } } Tri = tile; C4SNetFree(Fac); } else { Tri = Fac; } for (j = K; j < P; ++j) { if (verbose) { printf("%s: -> Tri, N=%d, B=%d, (%d, %d, )\n", __func__, N, B, K, j); } C4SNetOut(hnd, 1, C4SNetShallowCopy(Tri), N, B, K, j); } /* printf("%s: -> Out, N=%d, B=%d, (%d, %d, %d)\n", __func__, N, B, K, K - 1, K - 1); */ C4SNetOut(hnd, 2, Tri, N, B, K, K - 1, K - 1); return hnd; }
void *showB( void *hnd, c4snet_data_t *x) { int int_x = *(int *)C4SNetGetData( x); c4snet_data_t *result; printf("%s: %d\n", __func__, int_x); result = C4SNetCreate(CTYPE_int, 1, &int_x); C4SNetFree(x); C4SNetOut( hnd, 1, result); return hnd; }
void *dec( void *hnd, c4snet_data_t *x) { int int_x; c4snet_data_t *result; int_x= *(int *)C4SNetGetData( x); int_x -= 1; result = C4SNetCreate(CTYPE_int, 1, &int_x); C4SNetFree(x); C4SNetOut( hnd, 1, result); return( hnd); }
void * finalize (void *hnd, c4snet_data_t * fltiles, int bs, int p) { struct timespec end; tile * tiles = *((tile **) C4SNetGetData (fltiles)); if (clock_gettime(CLOCK_REALTIME, &end)) { pexit("clock_gettime"); } printf("Time for size %d x %d : %lf sec\n", bs * p, bs * p, delta_time(begin, end)); write_matrix(tiles, p, bs); C4SNetOut (hnd, 1, C4SNetCreate (CTYPE_char, 5, "Done.")); C4SNetFree (fltiles); return hnd; }
void * compute_s1 (void *hnd, c4snet_data_t * atiles, c4snet_data_t * ltiles, int bs, int p, int k) { int k_b, j_b, j, i_b, j_bb; tile * a_tiles = *((tile **) C4SNetGetData (atiles)); tile * l_tiles = *((tile **) C4SNetGetData (ltiles)); for (k_b = 0; k_b < bs; k_b++) { l_tiles[k * p + k][k_b * bs + k_b] = sqrt (a_tiles[k * p + k][k_b * bs + k_b]); for (j_b = k_b + 1; j_b < bs; j_b++) l_tiles[k * p + k][k_b * bs + j_b] = a_tiles[k * p + k][k_b * bs + j_b] / l_tiles[k * p + k][k_b * bs + k_b]; for (j_bb = k_b + 1; j_bb < bs; j_bb++) for (i_b = j_bb; i_b < bs; i_b++) a_tiles[k * p + k][i_b * bs + j_bb] = a_tiles[k * p + k][i_b * bs + j_bb] - l_tiles[k * p + k][k_b * bs + i_b] * l_tiles[k * p + k][k_b * bs + j_bb]; } if (k + 1 < p) for (j = k + 1; j < p; j++) C4SNetOut (hnd, 1, atiles, ltiles, bs, p, k, j); else { int i, j; C4SNetOut (hnd, 2, ltiles, bs, p); /* deallocate a_tiles array and remove atiles field. */ for (i = 0; i < p; i++) for (j = 0; j <= i; j++) free (a_tiles[j * p + i]); free (a_tiles); C4SNetFree (atiles); } return hnd; }
void *split(void *hnd, c4snet_data_t *entries, int num_entries) { c4snet_data_t *hash_cdata; c4snet_data_t *salt_cdata; char *data, *hash, *salt, *first, *middle, *last; first = data = C4SNetGetData(entries) for (int i = 0; i < num_entries; i++) { last = strchr(first, '\n'); if (last == NULL) last = &data[strlen(data)]; for (int j = 0, middle = first; j < 3; j++) { middle = strchr(middle, '$') + 1; } hash_cdata = C4SNetAlloc(CTYPE_char, middle - first + 1, &hash); salt_cdata = C4SNetAlloc(CTYPE_char, last - first + 1, &salt); strncpy(salt, first, middle - first); salt[middle - first] = '\0'; strncpy(hash, first, last - first); hash[last - first] = '\0'; C4SNetOut(hnd, 1, hash_cdata, salt_cdata, i); first = last + 1; } C4SNetFree(entries); return hnd; }
/* Do the TriangularSolve from input tiles Tri and Tri2. */ void *trisol(void *hnd, c4snet_data_t *Tri, c4snet_data_t *Tri2, int N, int B, int K, int J) { c4snet_data_t *Out; c4snet_data_t *Sym; c4snet_data_t *Sym2; const int P = N / B; int i, j; if (verbose) { printf("%s: %p, %p, N=%d, B=%d, (%d, %d, )\n", __func__, Tri, Tri2, N, B, K, J); } if (compute) { tile_t A = C4SNetGetData(Tri2); tile_t Li = C4SNetGetData(Tri); void *tile_ptr; c4snet_data_t *tile = C4SNetAlloc(CTYPE_double, B * B, &tile_ptr); tile_t Lo = tile_ptr; int k_b, i_b, j_b; for (k_b = 0; k_b < B; ++k_b) { for (i_b = 0; i_b < B; ++i_b) { Lo[i_b + k_b * B] = A[i_b + k_b * B] / Li[k_b + k_b * B]; } for (j_b = k_b + 1; j_b < B; ++j_b) { for (i_b = 0; i_b < B; ++i_b) { A[i_b + j_b * B] -= Li[j_b + k_b * B] * Lo[i_b + k_b * B]; } } } Out = Sym = Sym2 = tile; C4SNetFree(Tri); C4SNetFree(Tri2); } else { Out = Sym = Sym2 = Tri; C4SNetFree(Tri2); } for (i = K + 1; i <= J; ++i) { if (verbose) { printf("%s: -> Sym(%d,%d)a, N=%d, B=%d, (%d, %d, %d)\n", __func__, K, J, N, B, K, J, i); } C4SNetOut(hnd, 1, C4SNetShallowCopy(Sym), N, B, K, J, i); if (i == J && i != K) { if (verbose) { printf("%s: -> Sym2(%d,%d)a, (%d, %d, %d)\n", __func__, K, J, K, J, i); } C4SNetOut(hnd, 2, C4SNetShallowCopy(Sym2), K, J, i); } } for (j = J; j < P; ++j) { if (j == J && j != K) { if (verbose) { printf("%s: -> Sym(%d,%d)b, N=%d, B=%d, (%d, %d, %d)\n", __func__, K, J, N, B, K, j, K); } C4SNetOut(hnd, 1, C4SNetShallowCopy(Sym2), N, B, K, j, K); } else { if (verbose) { printf("%s: -> Sym2(%d,%d)c, (%d, %d, %d)\n", __func__, K, J, K, j, J); } C4SNetOut(hnd, 2, C4SNetShallowCopy(Sym2), K, j, J); } if (j == K) { if (verbose) { printf("%s: -> Sym(%d,%d)d, N=%d, B=%d, (%d, %d, %d)\n", __func__, K, J, N, B, K, j, K); } C4SNetOut(hnd, 1, C4SNetShallowCopy(Sym), N, B, K, j, K); } } C4SNetOut(hnd, 3, Out, N, B, K, J, K - 1); return hnd; }
/* Do the SymmetricRankUpdate step from input tiles Sym, Sym2, Sym3. */ void *rankup(void *hnd, c4snet_data_t *Sym, c4snet_data_t *Sym2, c4snet_data_t *Sym3, int N, int B, int K, int J, int I) { c4snet_data_t *Fac = Sym3; c4snet_data_t *Tri2 = Sym3; if (verbose) { printf("%s: %p, %p, %p, N=%d, B=%d, (%d, %d, %d)\n", __func__, Sym, Sym2, Sym3, N, B, K, J, I); } if (compute) { tile_t L1, L2, A = C4SNetGetData(Sym3); int i_b, j_b, k_b; assert( K <= I && I <= J ); if (I == J) { /* L2 = get_tile(ctx, K + 1, J, K); */ L2 = C4SNetGetData(Sym); L1 = NULL; } else { /* L2 = get_tile(ctx, K + 1, I, K); */ L2 = C4SNetGetData(Sym2); /* L1 = get_tile(ctx, K + 1, J, K); */ L1 = C4SNetGetData(Sym); } for (j_b = 0; j_b < B; ++j_b) { for (k_b = 0; k_b < B; ++k_b) { double temp = -L2[j_b + k_b * B]; if (I != J) { for (i_b = 0; i_b < B; ++i_b) { A[i_b + j_b * B] += temp * L1[i_b + k_b * B]; } } else { for (i_b = j_b; i_b < B; ++i_b) { A[i_b + j_b * B] += temp * L2[i_b + k_b * B]; } } } } C4SNetFree(Sym); C4SNetFree(Sym2); } if (K == J && J == I) { if (verbose) { printf("%s: -> Fac, N=%d, B=%d, (%d, , )\n", __func__, N, B, K + 1); } C4SNetOut(hnd, 1, Fac, N, B, K + 1); } else if (K == I) { if (verbose) { printf("%s: -> Tri2, (%d, %d, )\n", __func__, K + 1, J); } C4SNetOut(hnd, 2, Tri2, K + 1, J); } else { if (verbose) { printf("%s: -> Sym3, (%d, %d, %d)\n", __func__, K + 1, J, I); } C4SNetOut(hnd, 3, Sym3, K + 1, J, I); } return hnd; }
void *sink(void *hnd, c4snet_data_t *ct) { C4SNetFree(ct); return hnd; }
void *Merger (void *hnd, c4snet_data_t *total_ele, c4snet_data_t *count, c4snet_data_t *submatrix_in_one_row, c4snet_data_t *size_matrix, c4snet_data_t *size_submatrix, c4snet_data_t *result, c4snet_data_t *submatrix_result, c4snet_data_t *position) { int int_total_ele = * (int *) C4SNetGetData(total_ele); int int_count = * (int *) C4SNetGetData(count); int *int_submatrix_result = C4SNetGetData(submatrix_result); int *int_result = C4SNetGetData(result); int int_submatrix_in_one_row = * (int *) C4SNetGetData(submatrix_in_one_row); int int_size_matrix = * (int *) C4SNetGetData(size_matrix); int int_size_submatrix = * (int *) C4SNetGetData(size_submatrix); int int_position = * (int *) C4SNetGetData(position); int i, j; int positioni, positionj; int position_in_result; int_count = int_count + 1; positioni = int_position / int_submatrix_in_one_row; positionj = int_position % int_submatrix_in_one_row; for (i = 0; i < int_size_submatrix; i++) { for (j = 0; j < int_size_submatrix; j++) { position_in_result = (int_size_matrix * (i + (positioni * int_size_submatrix)) + j + (positionj * int_size_submatrix)); int_result[position_in_result] = int_result[position_in_result] + int_submatrix_result[(int_size_submatrix * i) + j]; } } if ( int_count < int_total_ele) { c4snet_data_t *new_result = C4SNetCreate(CTYPE_int, int_size_matrix*int_size_matrix, int_result); c4snet_data_t *c4_count = C4SNetCreate(CTYPE_int, 1, &int_count); C4SNetOut(hnd, 1, total_ele, c4_count, submatrix_in_one_row, size_matrix, size_submatrix, new_result); } else { printf("SOLUTION:\n"); for (i = 0; i < int_size_matrix; i++) { for (j = 0; j < int_size_matrix; j++) { printf("%d\t", int_result[(i*int_size_matrix) + j]); } printf("\n"); } C4SNetOut(hnd, 2, 0); C4SNetFree(total_ele); C4SNetFree(submatrix_in_one_row); C4SNetFree(size_matrix); C4SNetFree(size_submatrix); } C4SNetFree(submatrix_result); C4SNetFree(result); C4SNetFree(count); C4SNetFree(position); return hnd; }
/* Setup the S-Net computation: read matrix data from file and distribute. */ void *start(void *hnd, c4snet_data_t *InFile, c4snet_data_t *OutFile, int N, int B) { int P, X; int j, i; void *result_data; char *infile; c4snet_data_t *result; double *array_data; get_options(); /* Matrix size N must be a multiple of the block size B. */ if (B < 1 || N < 1 || N % B) { fprintf(stderr, "%s: matrix size %d is not a multiple of the block size %d\n", __func__, N, B); exit(1); } /* P gives the number of tiles in either dimension. */ P = N / B; /* X gives the number of tiles needed to construct the output. */ X = (P * P + P) / 2; /* Get the input filename as a string. */ infile = chars_to_string(InFile); C4SNetFree(InFile); if (verbose) { printf("%s: N=%d, B=%d, P=%d, X=%d, I=%s\n", __func__, N, B, P, X, infile); } result = C4SNetAlloc(CTYPE_long, P * P, &result_data); memset(result_data, 0, sizeof(long) * P * P); array_data = SNetMemAlloc(N * N * sizeof(double)); if (compute) { read_matrix(N, array_data, infile); } free(infile); if (clock_gettime(CLOCK_REALTIME, &begin)) { pexit("clock_gettime"); } /* Loop over the rows as j. */ for (j = 0; j < P; ++j) { /* Loop over the columns up to the diagonal as i. */ for (i = 0; i <= j; ++i) { void *tile_ptr; c4snet_data_t *tile = C4SNetAlloc(CTYPE_double, B * B, &tile_ptr); if (compute) { tile_t tile_data = (tile_t) tile_ptr; int A_y, T_y, A_x, T_x; for (A_y = j * B, T_y = 0; T_y < B; ++A_y, ++T_y) { for (A_x = i * B, T_x = 0; T_x < B; ++A_x, ++T_x) { tile_data[T_y + T_x * B] = array_data[A_y * N + A_x]; } } } else { memset(tile_ptr, 0, B * B * sizeof(double)); } if (j == 0 && i == 0) { if (verbose) { printf("%s: -> Fac, N=%d, B=%d, (1, , )\n", __func__, N, B); } C4SNetOut(hnd, 2, tile, N, B, 1); } else if (i == 0) { if (verbose) { printf("%s: -> Tri2, (1, %d, )\n", __func__, j); } C4SNetOut(hnd, 3, tile, 1, j); } else { if (verbose) { printf("%s: -> Sym3, (1, %d, %d)\n", __func__, j, i); } C4SNetOut(hnd, 4, tile, 1, j, i); } } } C4SNetOut(hnd, 1, OutFile, result, X); free(array_data); return hnd; }