/**
* 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);
}
/**
* 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);
}
c4snet_data_t *C4SNetDeepCopy(c4snet_data_t *data)
{
if (data->vtype == VTYPE_array) {
return C4SNetCreate(data->type, data->size, data->data.ptr);
}
return C4SNetCreate(data->type, data->size, &data->data);
}
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 *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;
new_result = C4SNetCreate(CTYPE_int, int_size_matrix*int_size_matrix, int_result);
C4SNetOut(hnd, 1, total_ele, C4SNetCreate(CTYPE_int, 1, &int_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);
}
return hnd;
}
/************ SOURCE SINK ***************/
void *source(void *hnd, int interval, int mess) {
char pt[8] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
char key[7] = {'1', '2', '3', '4', '5', '6', '7'};
int i;
for (i = 0; i < mess; i++) {
C4SNetOut(hnd, 1, C4SNetCreate(CTYPE_char, 8, &pt[0]), C4SNetCreate(CTYPE_char, 7, &key[0]));
usleep(interval); // sleep in microseconds
}
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 *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 *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 *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 *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 *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;
}
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 *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 *
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;
}
static c4snet_data_t *MPIUnpackFun(void *buf)
{
void *tmp;
c4snet_data_t *result;
int vtype, type, count;
SNetDistribUnpack(&vtype, buf, MPI_INT, 1);
SNetDistribUnpack(&count, buf, MPI_INT, 1);
SNetDistribUnpack(&type, buf, MPI_INT, 1);
if (vtype == VTYPE_array) {
result = C4SNetAlloc(type, count, &tmp);
SNetDistribUnpack(tmp, buf, TypeToMPIType(type), count);
} else {
result = C4SNetCreate(type, 1, &tmp);
SNetDistribUnpack(tmp, buf, TypeToMPIType(type), 1);
}
return result;
}
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;
}
void *Split (void* hnd, c4snet_data_t *matrix_A, c4snet_data_t *matrix_B, c4snet_data_t *size_matrix, c4snet_data_t *division)
{
int *int_matrix_A = C4SNetGetData(matrix_A);
int *int_matrix_B = C4SNetGetData(matrix_B);
int int_size_matrix = *(int *) C4SNetGetData(size_matrix);
int int_division = *(int *) C4SNetGetData(division);
int *int_result = malloc(sizeof(int) * int_size_matrix * int_size_matrix);
int **int_submatrix_collect_A = malloc(sizeof(int *) * int_division);
int **int_submatrix_collect_B = malloc(sizeof(int *) * int_division);
int i, j, k, z;
int repetition, row, col;
/*if (int_division <= 0 || int_size_matrix % sqrt(int_division) != 0)
{
printf("THe number of division is not possible. ");
return hnd;
}*/
int submatrix_in_one_row = sqrt(int_division);
int size_submatrix = (int_size_matrix / sqrt(int_division));
int varrow = 0;
int varcol = 0;
int *int_submatrix_A;
int *int_submatrix_B;
int *int_copy_matrix_A = malloc(sizeof(int) * int_size_matrix*int_size_matrix);
int *int_copy_matrix_B = malloc(sizeof(int) * int_size_matrix*int_size_matrix);
int_submatrix_A = malloc(sizeof(int) * size_submatrix*size_submatrix);
int_submatrix_B = malloc(sizeof(int) * size_submatrix*size_submatrix);
int position;
for ( repetition = 0; repetition < int_size_matrix; repetition++ )
{
row = 0;
col = 0;
for (i = 0; i < int_size_matrix; i++)
{
for (j = 0; j < int_size_matrix; j++)
{
if ( (j + row + repetition) < int_size_matrix )
{
int_copy_matrix_A[(i*int_size_matrix) + j] = int_matrix_A[ ( (i * int_size_matrix) + (j + row + repetition) )];
}
else
{
int_copy_matrix_A[(i*int_size_matrix) + j] = int_matrix_A[ ( (i * int_size_matrix) + ((j + row + repetition) % int_size_matrix) )];
}
if ( ( (i*int_size_matrix) + (col * int_size_matrix) + (repetition * int_size_matrix) ) < ( int_size_matrix * int_size_matrix ) )
{
int_copy_matrix_B[(i*int_size_matrix) + j] = int_matrix_B[ j + ( (i + col + repetition ) * int_size_matrix) ];
}
else
{
int_copy_matrix_B[(i*int_size_matrix) + j] = int_matrix_B[ j + (( (i + col + repetition ) * int_size_matrix) % (int_size_matrix * int_size_matrix)) ];
}
col++;
}
row++;
}
varrow = 0;
varcol = 0;
for ( position = 0; position < int_division; position++ )
{
for (i = 0; i < size_submatrix; i++)
{
for (j = 0; j < size_submatrix; j++)
{
int_submatrix_A[(i*size_submatrix) + j] = int_copy_matrix_A[(i + (varrow * size_submatrix))*int_size_matrix + (j + (varcol * size_submatrix))];
int_submatrix_B[(i*size_submatrix) + j] = int_copy_matrix_B[(i + (varrow * size_submatrix))*int_size_matrix + (j + (varcol * size_submatrix))];
}
}
// right
if ( (position + 1)% (int_size_matrix/size_submatrix) == 0 )
{
varcol = 0;
varrow++;
}
else //down and begin
{
varcol++;
}
// send data
C4SNetOut(hnd, 2, C4SNetCreate (CTYPE_int, size_submatrix*size_submatrix, int_submatrix_A),
C4SNetCreate (CTYPE_int, size_submatrix*size_submatrix, int_submatrix_B),
C4SNetCreate(CTYPE_int, 1, &size_submatrix), C4SNetCreate(CTYPE_int, 1, &position));
}
}
// Second message
// int_size_matrix * int_size_matrix * submatrix_in_one_row = number of operations of submatrix
int total_ele = int_size_matrix * int_division;
int count = 0;
c4snet_data_t *result;
for (i = 0; i < int_size_matrix; i++)
{
for (j = 0; j < int_size_matrix; j++)
{
int_result[(i*int_size_matrix) + j] = 0;
}
}
result = C4SNetCreate (CTYPE_int, int_size_matrix*int_size_matrix, int_result);
C4SNetOut(hnd, 1, C4SNetCreate(CTYPE_int, 1, &total_ele), C4SNetCreate(CTYPE_int, 1, &count), C4SNetCreate(CTYPE_int, 1, &submatrix_in_one_row), size_matrix, C4SNetCreate(CTYPE_int, 1, &size_submatrix), result);
return hnd;
}
