/**
* 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;
}
