static void init_matrices(group_t *grp)
{
int size = grp->matrix_size;
int index = grp->group_id;
int credit = grp->credit_value;
matrices_A[index] = (matrix_t*)MALLOCZ_SAFE(sizeof(matrix_t));
matrices_B[index] = (matrix_t*)MALLOCZ_SAFE(sizeof(matrix_t));
matrices_C[index] = (matrix_t*)MALLOCZ_SAFE(sizeof(matrix_t));
matrices_A[index]->m = (int *)MALLOCZ_SAFE((sizeof(int))*size*size);
matrices_B[index]->m = (int *)MALLOCZ_SAFE((sizeof(int))*size*size);
matrices_C[index]->m = (int *)MALLOCZ_SAFE((sizeof(int))*size*size);
group_t *grp_A = (group_t *)MALLOCZ_SAFE(sizeof(group_t));
group_t *grp_B = (group_t *)MALLOCZ_SAFE(sizeof(group_t));
group_t *grp_C = (group_t *)MALLOCZ_SAFE(sizeof(group_t));
grp_A->matrix_size = grp_B->matrix_size = grp_C->matrix_size = size;
grp_A->credit_value = grp_B->credit_value = grp_C->credit_value = credit;
grp_A->group_id = grp_B->group_id = grp_C->group_id = index;
matrices_A[index]->matrix_group = grp_A;
matrices_B[index]->matrix_group = grp_B;
matrices_C[index]->matrix_group = grp_C;
generate_matrix(matrices_A[index], 1, size);
generate_matrix(matrices_B[index], 1, size);
generate_matrix(matrices_C[index], 0, size);
return;
}
static void init_matrices() {
int i = 0;
for (i=0; i<4; ++i) {
generate_matrix(&A[i], 1, sizes[i]);
generate_matrix(&B[i], 1, sizes[i]);
generate_matrix(&C[i], 0, sizes[i]);
}
return;
}
int main(int argc, char **argv)
{
int size;
int sparsity;
int diagonality = 10;
char* matrix_file = "/tmp/matrix.txt";
char* vector_file = "/tmp/vector.txt";
if (argc == 3 || argc == 4)
{
size = atoi(argv[1]);
sparsity = atoi(argv[2]);
// if (argc >= 5)
// {
// matrix_file = argv[3];
// vector_file = argv[4];
// }
if (argc == 4)
{
diagonality = atoi(argv[3]);
}
}
else
{
printf("Usage: generate_matrix size sparsity diagonality filename\n size - number of rows/columns\n");
printf(" sparsity - integer > 0, higher sparsity indices result in sparser matrices\n");
printf(" diagonality - 0 for uniform distribution, 1 for diagonal\n");
printf(" filename - optional filename, 'matrix.txt' is default\n");
exit(-1);
}
generate_matrix(size, sparsity, diagonality, matrix_file);
generate_vector(size, vector_file);
return 0;
}
int main() {
int num;
printf("How many digits? : ");
scanf("%d",&num);
generate_matrix(num);
return 0;
}
double soft_cos_similarity(char *x_matrix_str, char *y_matrix_str)
{
Matrix x_matrix = generate_matrix(x_matrix_str);
Matrix y_matrix = generate_matrix(y_matrix_str);
double similarity = 0.0;
for (int i = 0; i < x_matrix.len; i++) {
for (int j = 0; j < y_matrix.len; j++) {
double word_sim = white_similarity(x_matrix.words[i], y_matrix.words[j]);
similarity += (word_sim * x_matrix.values[i] * y_matrix.values[j]);
}
}
free_matrix(x_matrix);
free_matrix(y_matrix);
return similarity;
}
static void * kadane_alg_threaded (void * pa)
{
ARGS *pargs = (ARGS*) pa;
cpu_set_t CPU_ID;
int i;
int *pps;
CPU_ZERO(&CPU_ID);
CPU_SET(pargs->CPU_ID, &CPU_ID);
sched_setaffinity(0, sizeof(cpu_set_t), &CPU_ID);
generate_matrix(pargs->n, pargs->m,
pargs->thread_number, pargs->total_threads,
pargs->ps, pargs->len, pargs->prelen,
pargs->cycle, pargs->precycle, pargs->sync);
kadane_thread(pargs->n, pargs->m, pargs->MAX_ROW,
pargs->total_threads, pargs->thread_number,
pargs->ps, pargs->workspace, &(pargs->result));
return 0;
}
int llc_test_driver (const char *parm, const int *list,
DATASET *dset, gretlopt opt, PRN *prn)
{
gretl_matrix *m = NULL;
int *plist = NULL;
int p0 = -1;
int err = 0;
if (*parm == '{') {
m = generate_matrix(parm, dset, &err);
if (!err) {
plist = gretl_list_from_vector(m, &err);
}
gretl_matrix_free(m);
} else if (gretl_is_matrix(parm)) {
m = get_matrix_by_name(parm);
plist = gretl_list_from_vector(m, &err);
} else if (integer_string(parm)) {
p0 = atoi(parm);
} else if (gretl_is_scalar(parm)) {
p0 = gretl_scalar_get_value(parm, NULL);
} else {
err = E_DATA;
}
if (!err) {
if (plist != NULL) {
err = levin_lin_test(list[1], plist, dset, opt, prn);
free(plist);
} else {
int tmplist[2] = {1, p0};
err = levin_lin_test(list[1], tmplist, dset, opt, prn);
}
}
return err;
}
MODEL quantreg_driver (const char *parm, const int *list,
DATASET *dset, gretlopt opt, PRN *prn)
{
gretl_vector *tau;
MODEL mod;
int err = 0;
tau = generate_matrix(parm, dset, &err);
if (!err && gretl_vector_get_length(tau) == 0) {
err = E_DATA;
}
if (err) {
gretl_model_init(&mod, dset);
mod.errcode = err;
} else {
mod = quantreg(tau, list, dset, opt, prn);
}
gretl_matrix_free(tau);
return mod;
}
int readphase (Ctrl_str * cp, BB_struct * bp)
{
char line[MAX_STRING_LEN];
char *token;
int i, j, itmp, n, npaded;
int nx, ny, nz, nc;
int rflag = 0;
int index = 0;
int error = FALSE;
Mat_str *mp;
Nuc_str *np;
P_str *pp;
MultiS_struct *ms;
int ele_num, ele_1;
CA_FLOAT *Cinit_multi_ptr;
CA_FLOAT **Clim_multi_ptr;
FILE *fileout;
ms = &(bp->MultiSvals); /* local variable for the multi diff values */
pp = &(bp->pprops);
mp = &(bp->mprops);
np = &(bp->nprops);
nx = bp->nc[0];
ny = bp->nc[1];
nz = bp->nc[2];
nc = bp->ncsb;
npaded = (nx + 2) * (ny + 2) * (nz + 2);
bp->ntsb = bp->nsb[0] * bp->nsb[1] * bp->nsb[2];
/*from read_ctrl.h */
ele_num = D_NUM_COMP;
/*******/
ele_num = cp->NUM_COMP; /*number of components in the alloy */
ele_1 = ele_num - 1;
fileout = fopen ("phase_out", "a+");
/*******************read liquidus temperature and solute concentration****/
/*******************from the input file provided by thermocalc************/
/*********************************************************/
/* Open the file */
/*********************************************************/
if ((cp->fd_phadia = fopen (cp->fn_phadia, "r")) == NULL) {
fprintf (stderr, "Error: can't open input file [%s]\n", cp->fn_phadia);
exit (0);
}
while (fgets (line, MAX_STRING_LEN, cp->fd_phadia) != NULL) {
/* ignore comment and blank lines */
if (line[0] == '%' || line[0] == '#' || line[0] == '\n' || (token = strtok (line, " ,;\t")) == NULL) {
continue;
/*********************************************************/
/* values for liquidus and solute concentration in liquid */
/*********************************************************/
/* number of tie-triangles produced by thermocalc */
} else if (strcasecmp (token, "NumTieTri") == 0) {
if ((token = strtok (NULL, " ,;\t")) != NULL) {
ms->numtietri = atoi (token);
} else {
ms->numtietri = D_NUMTIETRI;
}
} else {
/*****assign the first token for each loop****/
ms->phaval[index][0] = atof (token);
for (i = 1; i <= 3; i++) {
if ((token = strtok (NULL, " ,;\t")) != NULL) {
ms->phaval[index][i] = atof (token);
}
}
index++;
}
} /* end of while routine */
/******************call generate_matrix routine********************/
generate_matrix (cp, bp);
/*******************print test for the phase diagram routine******/
for (i = 0; i < ms->numtietri; i++) {
fprintf (fileout, "%d \t %f \t %f \t %f \t %f \n", i, ms->phaval[i][0], ms->phaval[i][1], ms->phaval[i][2], ms->phaval[i][3]);
}
for (i = 1; i <= 4; i++) {
fprintf (fileout, "row number %d with %d elements is printed below \n \n", i, ms->counter[i]);
for (j = 1; j <= ms->counter[i]; j++) {
fprintf (fileout, "%d \t %f \n", j, ms->xxa[i][j]);
}
}
for (i = 1; i <= ms->counter[3]; i++) {
for (j = 1; j <= ms->counter[4]; j++) {
fprintf (fileout, "liquidus function, index %d and %d = %f for %f and %f \n", i, j, ms->ya1[i][j], ms->xxa[3][i],
ms->xxa[4][j]);
}
}
fclose (fileout);
return (1);
}
int main(int argc, char * argv[])
{
parse_args(argc, argv);
const int size = n * n;
int data_size_bytes = size * sizeof(float);
float *mat_a = malloc(data_size_bytes);
float *mat_b = malloc(data_size_bytes);
float *vector;
float *output = malloc(data_size_bytes);
float *expected = malloc(data_size_bytes);
generate_matrix(n, mat_a, range);
generate_matrix(n, mat_b, range);
timing_t timer;
timer_start(&timer);
float *mat_b_trans = malloc(data_size_bytes);
transpose(n, mat_b, mat_b_trans);
for (int i=0; i<n; ++i) {
vector = &mat_b_trans[n*i];
MatMatMultiply(n, mat_a, vector, &output[n*i]);
}
float *output_trans = malloc(data_size_bytes);
transpose(n, output, output_trans);
timer_stop(&timer);
float sum = sum_mat(size, output_trans);
printf("%d %f %ld %ld\n", n, sum, timer.realtime, timer.cputime);
int status = 0;
if (trace == 1) {
printf("\nMatrix A\n");
for (int i=0; i<n; i++){
for (int j=0; j<n; j++){
printf("%f " , mat_a[i*n+j]);
}
printf("\n");
}
printf("\nMatrix B \n");
for (int i=0; i<n; i++){
for (int j=0; j<n; j++){
printf("%f " , mat_b[i*n+j]);
}
printf("\n");
}
printf("\n\nResult\n");
for (int i=0; i<n; i++){
for (int j=0; j<n; j++){
printf("%f " , output[i*n+j]);
}
printf("\n");
}
}
else if (trace == 2) {
multiply_CPU_matrix(n, mat_a, mat_b, expected);
int status = check(size, output_trans, expected);
if (status) {
printf("Test failed.\n");
status = 1;
}
else
printf("Test passed OK!\n");
}
free(mat_a);
free(mat_b);
free(mat_b_trans);
free(output);
free(expected);
free(output_trans);
return status;
}
int main(int argc, char *argv[]) {
int node_index, node_count;
int size;
int block_size;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &node_index);
MPI_Comm_size(MPI_COMM_WORLD, &node_count);
if (node_index == 0) {
sprintf(buf, "result%d.txt", node_count);
freopen(buf, "w", stdout);
}
// Timer started
MPI_Barrier(MPI_COMM_WORLD);
if (node_index == 0)
timer_start();
if (argc != 3 && argc != 4) {
if (node_index == 0)
printf("Usage: %s matrix_size block_size [input_file]\n", argv[0]);
MPI_Finalize();
return -1;
} else {
size = atoi(argv[1]);
block_size = atoi(argv[2]);
if ((size < 2) || (block_size < 1) || (block_size > size)) {
if (node_index == 0) {
printf("Wrong format matrix_size > 1, matrix_size >= block_size > 0\n");
printf("Usage: %s matrix_size block_size [input_file]\n", argv[0]);
}
MPI_Finalize();
return -2;
}
}
int memlen = size + node_count * block_size - 1;
memlen /= node_count * block_size;
memlen *= block_size * size;
double *data = new double [memlen];
memset(data, 0, memlen * sizeof(double));
if (argc == 3) {
generate_matrix(MATRIX_INDEX, size, block_size, node_index, node_count, data);
} else {
if (read_matrix_file(argv[3], size, block_size, node_index, node_count, data)) {
if (node_index == 0)
printf("Cannot open(read from) file: %s\n", argv[3]);
delete[] data;
MPI_Finalize();
return -3;
}
}
print_matrix(size, block_size, node_index, node_count, data);
// Initialization done!
MPI_Barrier(MPI_COMM_WORLD);
if (node_index == 0)
print_full_time("on init");
if (spd_inverse(size, block_size, node_index, node_count, data)) {
if (node_index == 0)
printf("Method cannot be applied!\n");
delete[] data;
MPI_Finalize();
return -4;
}
// Algorithm done!
MPI_Barrier(MPI_COMM_WORLD);
if (node_index == 0)
print_full_time("on algorithm");
// Printing result on console (and in file)
downtr_to_symm(size, block_size, node_index, node_count, data);
print_matrix(size, block_size, node_index, node_count, data);
double *workspace = new double[memlen];
memset(workspace, 0, memlen * sizeof(double));
// For this two matrices inverse is known
if (MATRIX_INDEX == 1 || MATRIX_INDEX == 2) {
if (MATRIX_INDEX == 1)
generate_matrix(2, size, block_size, node_index, node_count, workspace);
else
generate_matrix(1, size, block_size, node_index, node_count, workspace);
sub_array(memlen, data, workspace);
double err_norm = inf_norm_matrix(size, block_size,
node_index, node_count, workspace);
err_norm = 0;
// if (node_index == 0)
// printf("Error = %11.5le\n", err_norm);
}
// Restore input matrix to calculate residual
if (argc == 3) {
generate_matrix(MATRIX_INDEX, size, block_size, node_index, node_count, workspace);
} else {
if (read_matrix_file(argv[3], size, block_size, node_index, node_count, workspace)) {
if (node_index == 0)
printf("Cannot open(read from) file: %s\n", argv[3]);
delete[] data;
delete[] workspace;
MPI_Finalize();
return -5;
}
}
#ifdef PRINT_RESULT_TO_FILE
if (print_matrix_file(output, size, block_size, node_index, node_count, data)) {
if (node_index == 0)
printf("Cannot open(print to) file: %s\n", output);
delete[] data;
delete[] workspace;
MPI_Finalize();
return -6;
}
#endif
double *residual = new double[memlen];
tmatrix_mul(size, block_size, node_index, node_count, workspace, data, residual);
generate_matrix(-2, size, block_size, node_index, node_count, residual);
generate_matrix(0, size, block_size, node_index, node_count, workspace);
sub_array(memlen, workspace, residual);
downtr_to_symm(size, block_size, node_index, node_count, residual);
double res_norm = inf_norm_matrix(size, block_size, node_index, node_count, residual);
if (node_index == 0)
printf("Residual = %11.5le\n", res_norm);
delete[] data;
delete[] workspace;
delete[] residual;
MPI_Finalize();
return 0;
}
void test_tensor_crs_matrix( const size_t M , const size_t N , const bool print = false )
{
const size_t length = N * N * N ;
typedef IntType value_type ; // to avoid comparison round-off differences
typedef KokkosArray::View<value_type**,KokkosArray::LayoutLeft,Device>
block_vector_type ;
typedef KokkosArray::SparseProductTensor< 3 , IntType , Device > block_spec ;
typedef KokkosArray::BlockCrsMatrix< block_spec , value_type , Device > matrix_type ;
typedef typename matrix_type::graph_type graph_type ;
typedef KokkosArray::ProductTensorIndex<3,Device> index_type ;
matrix_type matrix ;
generate_matrix( M , N , matrix );
block_vector_type x = block_vector_type( "x" , M , length );
block_vector_type y = block_vector_type( "y" , M , length );
typename block_vector_type::HostMirror hx = KokkosArray::create_mirror( x );
typename block_vector_type::HostMirror hy = KokkosArray::create_mirror( y );
for ( size_t i = 0 ; i < length ; ++i ) {
for ( size_t j = 0 ; j < M ; ++j ) {
hx(j,i) = 1 + j + 10 * i ;
}
}
KokkosArray::deep_copy( x , hx );
KokkosArray::multiply( matrix , x , y );
KokkosArray::deep_copy( hy , y );
// Check answer:
typename graph_type::HostMirror h_graph =
KokkosArray::create_mirror( matrix.graph );
std::map< index_type , IntType > tensor_input ;
generate_tensor( M , tensor_input );
for ( size_t outer_row = 0 ; outer_row < length ; ++outer_row ) {
const size_t outer_entry_begin = h_graph.row_map[outer_row];
const size_t outer_entry_end = h_graph.row_map[outer_row+1];
for ( size_t inner_row = 0 ; inner_row < M ; ++inner_row ) {
value_type value = 0 ;
for ( size_t outer_entry = outer_entry_begin ;
outer_entry < outer_entry_end ; ++outer_entry ) {
const size_t outer_column = h_graph.entries( outer_entry );
for ( typename std::map< index_type , IntType >::iterator
iter = tensor_input.begin() ;
iter != tensor_input.end() ; ++iter ) {
const index_type index = (*iter).first ;
const IntType coeff = (*iter).second ;
size_t i , j ;
if ( inner_row == index.coord(2) ) {
i = index.coord(0);
j = index.coord(1);
}
else if ( inner_row == index.coord(1) ) {
i = index.coord(0);
j = index.coord(2);
}
else if ( inner_row == index.coord(0) ) {
i = index.coord(1);
j = index.coord(2);
}
else {
continue ;
}
const IntType ai = generate_matrix_value( i , outer_row , outer_column );
const IntType aj = generate_matrix_value( j , outer_row , outer_column );
value += coeff * ( i == j ? ( ai * hx( i , outer_column ) )
: ( ai * hx( j , outer_column ) +
aj * hx( i , outer_column ) ) );
}
}
if ( value != hy(inner_row,outer_row) ) {
std::ostringstream msg ;
msg << "correctness test failed "
<< value << " != " << hy(inner_row,outer_row)
<< " = hy( " << inner_row << "," << outer_row << ")" ;
throw std::runtime_error(msg.str());
}
else if ( print ) {
std::cout << " = hy( " << inner_row << "," << outer_row << ") = "
<< hy( inner_row , outer_row ) << std::endl ;
}
}
}
}
int main(int argc, char **argv) {
//int dims[3] = {5,10,15};
//int dim = 4;
//int block_dim = 2;
double time,avg;
MPI_Init(&argc, &argv);
int procs;
int rank;
MPI_Comm_size(MPI_COMM_WORLD, &procs);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
#if doPAPI==1
data = 0;
papi_setup();
#endif
//Check if number of processes is a perfect square
if (sqrt(procs) != floor(sqrt(procs))) {
printf("Number of processes is not a perfect square!\n");
return -1;
}
//Read input arguements
if(argc < 2) {
if(rank == 0)
fprintf(stderr,"Wrong # of arguments.\nUsage: mpirun -n procs %s $dim $numThreads $rank2print $doSerial(Only dim and numThreads are required; other 2 are optional)\n",argv[0]);
return -1;
}
int dim = atoi(argv[1]);
int numThreads = atoi(argv[2]);
int block_dim = dim/(sqrt(procs));
int rank2print = -1;
int doSerial = 0;
if(argc == 4) {
rank2print = atoi(argv[3]);
}
if(argc == 5) {
rank2print = atoi(argv[3]);
doSerial = atoi(argv[4]);
}
//Run code
if(rank==0)
printf("Running code on %i procs with dim = %i; numThreads = %i; block_dim = %i; printing on rank %i; doSerial = %i \n",procs, dim, numThreads, block_dim, rank2print, doSerial);
if(doSerial==1)
serial_lu(generate_matrix(dim),dim);
#if doPAPI==1
papi_start();
parallel_lu(argc, argv, generate_matrix(dim), dim, block_dim, rank2print, doSerial, numThreads);
papi_report();
#else
time = MPI_Wtime();
parallel_lu(argc, argv, generate_matrix(dim), dim, block_dim, rank2print, doSerial, numThreads);
time = MPI_Wtime() - time;
MPI_Reduce(&time, &avg, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
if(rank == 0) {
printf("Dim = %i, Procs = %i, Threads = %i, Average time: %e\n", dim, procs, numThreads, avg/procs);
}
#endif
MPI_Finalize();
return 0;
}
int main(int argc, char * argv[])
{
if (argc > 1){
parse_args(argc, argv);
}
const int size = n * n;
float *mat = malloc(size * sizeof(float));
float *vec = malloc(n * sizeof(float));
float *output = malloc(n * sizeof(float));
float *expected = malloc(n * sizeof(float));
float *mat_transposed = malloc(n * n * sizeof(float));
generate_matrix(n, mat, range);
generate_vector(n, vec, range);
timing_t timer1;
timer_start(&timer1);
transpose(n, mat, mat_transposed);
MatVecMultiply(size, n, mat_transposed, vec, output);
timer_stop(&timer1);
float sum = sum_vec(n, output);
printf("%d %f %ld %ld\n", n, sum, timer1.realtime, timer1.cputime);
if (trace == 1) {
printf("\nInput matrix\n");
for (int i=0; i<n; i++){
for (int j=0; j<n; j++){
printf("%f " , mat[i*n+j]);
}
printf("\n");
}
printf("\nInput vector \n");
for (int i=0; i<n; i++){
printf("%f " , vec[i]);
}
printf("\n\nResult\n");
for (int i=0; i<n; i++){
printf("%f " , output[i]);
}
printf("\n");
}
else if (trace == 2) {
multiply_CPU(n, mat, vec, expected);
int status = check(n, output, expected);
if (status)
printf("Test failed.\n");
else
printf("Test passed OK!\n");
return status;
}
free(mat);
free(vec);
free(output);
free(expected);
free(mat_transposed);
return 0;
}
int
main (int argc, char **argv)
{
int mpi_rank, mpi_size;
int n, ln;
double *A, *b, *xA, *xB, *xC, *r, *X, *x;
double lmax, max;
struct timeval before, after;
MPI_Init (&argc, &argv);
MPI_Comm_size (MPI_COMM_WORLD, &mpi_size);
MPI_Comm_rank (MPI_COMM_WORLD, &mpi_rank);
/* Get the argument that indicates the problem size */
n = JACOBI_DEF_SIZE;
if (argc == 2)
n = atoi (argv[1]);
if (mpi_rank == ROOT_NODE)
fprintf (stdout, "n = %d\n", n);
ln = n / mpi_size;
/* Initialize the random seed */
/*srandom((unsigned int) getpid ());*/
/* Allocate memory */
A = (double *) calloc (ln * n, sizeof(double));
if (A == NULL)
{
perror ("calloc");
MPI_Finalize ();
return EXIT_FAILURE;
}
b = (double *) calloc (ln, sizeof(double));
if (b == NULL)
{
perror ("calloc");
MPI_Finalize ();
return EXIT_FAILURE;
}
xA = (double *) calloc (ln, sizeof(double));
if (xA == NULL)
{
perror ("calloc");
MPI_Finalize ();
return EXIT_FAILURE;
}
xB = (double *) calloc (ln, sizeof(double));
if (xB == NULL)
{
perror ("calloc");
MPI_Finalize ();
return EXIT_FAILURE;
}
xC = (double *) calloc (ln, sizeof(double));
if (xC == NULL)
{
perror ("calloc");
MPI_Finalize ();
return EXIT_FAILURE;
}
X = (double *) calloc (n, sizeof(double));
if (X == NULL)
{
perror ("calloc");
MPI_Finalize ();
return EXIT_FAILURE;
}
r = (double *) calloc (ln, sizeof(double));
if (r == NULL)
{
perror ("calloc");
MPI_Finalize ();
return EXIT_FAILURE;
}
generate_matrix (A, ln, n, mpi_rank);
generate_vector (b, ln);
gettimeofday(&before, NULL);
x = jacobi (xA, xB, xC, A, b, ln, n, mpi_rank, mpi_size);
gettimeofday(&after, NULL);
MPI_Allgather (x, ln, MPI_DOUBLE,
X, ln, MPI_DOUBLE, MPI_COMM_WORLD);
/* Compute the residual */
compute_residual (r, A, X, b, ln, n);
/* Compute the maximum absolute value of the residual */
lmax = find_max_abs (r, ln);
MPI_Reduce (&lmax, &max, 1, MPI_DOUBLE, MPI_MAX, ROOT_NODE, MPI_COMM_WORLD);
if (mpi_rank == ROOT_NODE)
display_info (A, x, b, r, n, max, &before, &after);
/* Free the memory */
free (A);
free (b);
free (xA);
free (xB);
free (xC);
free (X);
free (r);
/* Return success */
MPI_Finalize ();
return 0;
}
void rm_test_0(ull r, ull m, int k, int max_iter, FILE *fout) {
ull wordsize = 0, dim = 0, gen_size = 0;
unsigned char *G = NULL, *D = NULL, *DD = NULL, *C = NULL, *NC = NULL;
unsigned short *masks = NULL, width = 0;
ull accumulator = 0, n = 0;
ull data_block_size_bytes = 0;
ull code_block_size_bytes = 0;
dim = rm_dim(r, m);
wordsize = rm_wordsize(r, m);
width = rm_codeword_size_in_bytes(r, m);
gen_size = gen_matrix_mem_size(m, m);
G = (unsigned char *) malloc(gen_size);
generate_matrix(m, m, G);
//print(dim, 8 * width, G);printf("\n");
masks = (unsigned short *) malloc(wordsize * sizeof(unsigned short));
generate_masks(m, masks);
data_block_size_bytes = rm_dataword_size_in_bytes(r, m);
code_block_size_bytes = rm_codeword_size_in_bytes(r, m);
D = (unsigned char *) malloc(data_block_size_bytes);
DD = (unsigned char *) malloc(data_block_size_bytes);
for (int i = 0; i < data_block_size_bytes; ++i)
D[i] = (unsigned char) rand();
C = (unsigned char *) malloc(code_block_size_bytes);
NC = (unsigned char *) malloc(code_block_size_bytes);
encode_block(r, m, dim, wordsize, C, D, masks, G);
//printf("Data:\n");print(1, dim, D);printf("\n");
memcpy(NC, C, width);
// print(1, wordsize, C);printf("\n");
// decode_block(r, m, dim, wordsize, NC, DD, masks, G, width);
// print(1, dim, DD);
srand (time(NULL));
n = 2 * k / 3 + 1;
fprintf(fout, "%lld\n", n);
for (ull i = 0; i < n; i++) {
accumulator = 0;
fprintf(fout, "%1.9lf ", (double) i / (double) k);
for (ull j = 0; j < max_iter; ++j) {
memcpy(NC, C, code_block_size_bytes);
add_noise(NC, code_block_size_bytes, (double) i / (double) k);
decode_block(r, m, dim, wordsize, NC, DD, masks, G, width);
accumulator += match(data_block_size_bytes, 0, dim, D, DD);
}
fprintf(fout, "%1.9lf\n", (double) accumulator / (double) max_iter);
}
FREE_IF_ALLOCATED(C);
FREE_IF_ALLOCATED(NC);
FREE_IF_ALLOCATED(D);
FREE_IF_ALLOCATED(DD);
FREE_IF_ALLOCATED(masks);
FREE_IF_ALLOCATED(G);
}
