int main(int argc, char* argv[]) {
if (argc < 2) {
printf("Parametros: [matriz]\n");
exit(1);
}
even_matrix = new_matrix_from_file(argv[1]);
odd_matrix = clone_matrix(even_matrix);
printf("Arquivo: %s\n", argv[1]);
printf("Calculando [...]\n\n");
pthread_barrier_init(&barrier, NULL, N_THREADS);
pthread_t *ptr_threads = (pthread_t *) malloc (N_THREADS * sizeof(pthread_t));
for (int i = 0; i < N_THREADS; i++) {
Data * sub_matrix = malloc(sizeof(Data));
sub_matrix->lin_min = i * (even_matrix.lin / N_THREADS);
sub_matrix->col_min = i * (even_matrix.col / N_THREADS);
sub_matrix->lin_max = (i + 1) * (even_matrix.lin / N_THREADS) - 1;
sub_matrix->col_max = (i + 1) * (even_matrix.col / N_THREADS) - 1;
pthread_create(&ptr_threads[i], NULL, calc_sor, (void*) sub_matrix);
}
for (int i = 0; i < N_THREADS; i++) {
pthread_join(ptr_threads[i], NULL);
}
pthread_barrier_destroy(&barrier);
Matrix result = merge(even_matrix, odd_matrix);
#ifdef TEST
print_matrix(result);
printf("\n");
#endif
matrix_to_file(result, "result.txt");
printf("Resultado gravado no arquivo: result.txt\n");
destroy_matrix(even_matrix);
destroy_matrix(odd_matrix);
return 1;
};
int spai
(matrix *A, matrix **spai_mat,
FILE *messages_arg, /* file for warning messages */
double epsilon_arg, /* tolerance */
int nbsteps_arg, /* max number of "improvement" steps per line */
int max_arg, /* max dimensions of I, q, etc. */
int maxnew_arg, /* max number of new entries per step */
int cache_size_arg, /* one of (1,2,3,4,5,6) indicting size of cache */
/* cache_size == 0 indicates no caching */
int verbose_arg,
int spar_arg,
int lower_diag_arg,
int upper_diag_arg,
double tau_arg)
{
matrix *M;
int col,ierr;
int cache_sizes[6];
/* Only create resplot for the numprocs=1 case. */
if (debug && (A->numprocs == 1)) {
resplot_fptr = fopen("resplot","w");
fprintf(resplot_fptr,
"ep=%5.5lf ns=%d mn=%d bs=%d\n",
epsilon_arg,nbsteps_arg,maxnew_arg,A->bs);
fprintf(resplot_fptr,"\n");
fprintf(resplot_fptr,"scol: scalar column number\n");
fprintf(resplot_fptr,"srn: scalar resnorm\n");
fprintf(resplot_fptr,"bcol: block column number\n");
fprintf(resplot_fptr,"brn: block resnorm\n");
fprintf(resplot_fptr,"* indicates epsilon not attained\n");
fprintf(resplot_fptr,"\n");
fprintf(resplot_fptr," scol srn bcol brn\n");
}
start_col = 0;
num_bad_cols = 0;
cache_sizes[0] = 101;
cache_sizes[1] = 503;
cache_sizes[2] = 2503;
cache_sizes[3] = 12503;
cache_sizes[4] = 62501;
cache_sizes[5] = 104743;
if (verbose_arg && !A->myid) {
if (spar_arg == 0)
printf("\n\nComputing SPAI: epsilon = %f\n",epsilon_arg);
else if (spar_arg == 1)
printf("\n\nComputing SPAI: tau = %f\n",tau_arg);
else if (spar_arg == 2)
printf("\n\nComputing SPAI: # diagonals = %d\n",
lower_diag_arg+upper_diag_arg+1);
fflush(stdout);
}
epsilon = epsilon_arg;
message = messages_arg;
maxnew = maxnew_arg;
max_dim = max_arg;
/* Determine maximum number of scalar nonzeros
for any column of M */
if (spar_arg == 0)
{
nbsteps = nbsteps_arg;
maxapi = A->max_block_size * (1 + maxnew*nbsteps);
}
else if(spar_arg == 1)
{
nbsteps = A->maxnz;
maxapi = A->max_block_size * (1 + nbsteps);
}
else
{
nbsteps = lower_diag_arg+upper_diag_arg+1;
maxapi = A->max_block_size * (1 + nbsteps);
}
allocate_globals(A);
#ifdef MPI
MPI_Barrier(A->comm);
#endif
if ((cache_size_arg < 0) || (cache_size_arg > 6)) {
fprintf(stderr,"illegal cache size in spai\n");
exit(1);
}
if (cache_size_arg > 0)
ht = init_hash_table(cache_sizes[cache_size_arg-1]);
M = clone_matrix(A);
ndone = 0;
Im_done = 0;
all_done = 0;
next_line = 0;
/* Timing of SPAI starts here.
In a "real production" code everything before this could be static.
*/
if (verbose_arg) start_timer(ident_spai);
if ((ierr = precompute_column_square_inverses(A)) != 0) return ierr;
#ifdef MPI
MPI_Barrier(A->comm);
#endif
for (;;) {
col = grab_Mline(A, M, A->comm);
if (debug && col >= 0) {
fprintf(fptr_dbg,"col=%d of %d\n",col,A->n);
fflush(fptr_dbg);
}
if (col < 0 ) break;
if ((ierr =
spai_line(A,col,spar_arg,lower_diag_arg,upper_diag_arg,tau_arg,M)) != 0) return ierr;
}
#ifdef MPI
say_Im_done(A,M);
do {
com_server(A,M);
}
while (! all_done);
MPI_Barrier(A->comm);
#endif
#ifdef MPI
MPI_Barrier(A->comm);
#endif
if (verbose_arg) {
stop_timer(ident_spai);
report_times(ident_spai,"spai",0,A->comm);
}
free_globals(nbsteps);
free_hash_table(ht);
if (resplot_fptr) fclose(resplot_fptr);
*spai_mat = M;
return 0;
}
SGMatrix<T> SGMatrix<T>::clone()
{
return SGMatrix<T>(clone_matrix(matrix, num_rows, num_cols),
num_rows, num_cols);
}
