/* Запустить таймер */
void timer_start (void)
{
TimerStarted = 1;
StartTime = PrevTime = get_time ();
#ifdef MEASURE_FULL_TIME
StartFullTime = PrevFullTime = get_full_time ();
#endif /* MEASURE_FULL_TIME */
}
/* Напечатать время от старта и от последнего вызова с заголовком MESSAGE */
void print_full_time (const char *message)
{
long t;
TIMER summ, stage;
#ifdef MEASURE_FULL_TIME
TIMER summ_full, stage_full;
long t_full = get_full_time ();
#endif /* MEASURE_FULL_TIME */
t = get_time ();
if (TimerStarted)
{
ConvertTime (t - StartTime, &summ);
ConvertTime (t - PrevTime, &stage);
#ifdef MEASURE_FULL_TIME
ConvertTime (t_full - StartFullTime, &summ_full);
ConvertTime (t_full - PrevFullTime, &stage_full);
#endif /* MEASURE_FULL_TIME */
#ifdef MEASURE_FULL_TIME
printf("Time: total=%2.2d:%2.2d:%2.2d.%2.2d (%2.2d:%2.2d:%2.2d.%2.2d), %s=%2.2d:%2.2d:%2.2d.%2.2d (%2.2d:%2.2d:%2.2d.%2.2d)\n",
summ.hour, summ.min, summ.sec, summ.tic,
summ_full.hour, summ_full.min, summ_full.sec, summ_full.tic,
message,
stage.hour, stage.min, stage.sec, stage.tic,
stage_full.hour, stage_full.min, stage_full.sec, stage_full.tic);
PrevFullTime = t_full;
#else
printf("Time: total=%2.2d:%2.2d:%2.2d.%2.2d, %s=%2.2d:%2.2d:%2.2d.%2.2d\n",
summ.hour, summ.min, summ.sec, summ.tic, message,
stage.hour, stage.min, stage.sec, stage.tic);
#endif /* MEASURE_FULL_TIME */
PrevTime = t;
}
else
{
TimerStarted = 1;
StartTime = PrevTime = t;
#ifdef MEASURE_FULL_TIME
StartFullTime = PrevFullTime = t_full;
#endif /* MEASURE_FULL_TIME */
}
}
/*
static void Print_start_data (const double *msr_matrix, const int *indexes, const int n, const int nz, const double *rhs, const int my_rank)
{
// Print matrix as arrays MSR ans INDEX
print_msr_NF (msr_matrix, indexes, nz, my_rank);
// Print rhs
printf ("rhs = ");
print_vector (rhs, n, my_rank);
}
*/
void *msr_solver (void* args)
{
// class matrix arguments
matrix_args *m_args = (matrix_args*)args;
int my_rank = m_args->get_my_rank ();
int total_thread = m_args->get_total_thread ();
// iteration definition
constexpr int maxit = 50;
constexpr int globalmaxit = 300;
constexpr double eps = 1e-4;
int iter = 0;
int glob_iter = 0;
double *msr_matrix = m_args->get_matrix (); //< MSR matrix
double *x = m_args->get_x (); //< solve
double *rhs = m_args->get_rhs (); //< right hand
double *workspace = m_args->get_workspace (); //< addition workspace
double *r = workspace; //< residual vector
int *indexes = m_args->get_indexes (); //< MSR IND vector
const int n = m_args->get_size (); //< size matrix
const int width = m_args->get_width (); //< widht of band matrix
double residual = 0; // residual
double full_time = 0;
// create msr matrix
create_msr_band_matrix (msr_matrix, indexes, width, n, my_rank, total_thread);
print_msr_matrix_SF (msr_matrix, indexes, n, my_rank);
print_msr_NF (msr_matrix, indexes, m_args->get_nozero (), my_rank);
// symmetry matrix
/* int sym = 0;
sym = is_symmetric_msr_matrix (indexes, n, my_rank);
if (sym)
{
printf ("MSR not symmtetry!!!\n");
}
*/
// set rhs = (1,0,1,0...)
set_rhs_vector (msr_matrix, indexes,rhs, n, my_rank, total_thread);
// set x = (1,0,1,0...)
set_init_solve_vector (x, n, my_rank, total_thread);
// Print_start_data (msr_matrix, indexes, n, nz, rhs, my_rank);
full_time = get_full_time (); // Initialize full time
m_args->set_thread_time (get_time ()); // Initialize time
for (glob_iter = 0; glob_iter < globalmaxit;)
{
iter = minimal_residual_solver (msr_matrix, indexes, n, rhs, x, workspace,
my_rank, total_thread, maxit, eps);
if (iter < 0)
{
glob_iter += maxit;
residual = get_residual (msr_matrix, indexes, n, x, rhs, r, my_rank, total_thread);
if (my_rank == 0)
printf("Failure: iters = %d residual = %4.8e\n", glob_iter, residual);
}
else
break;
}
// Finish time
full_time = get_full_time () - full_time;
m_args->set_thread_time(get_time () - m_args->get_thread_time ());
residual = get_residual (msr_matrix, indexes, n, x, rhs, r, my_rank, total_thread);
if (my_rank == 0)
{
double error = 0;
printf ("MATRIX: %s\nResidual = %e Error = %e\nFull_time = %f\n", "no-file", residual, error, full_time);
}
printf ("Thread # %d ------------------- CPU_thread_time = %f\n", my_rank, m_args->get_thread_time ());
synchronize (total_thread);
return 0;
}
int main(int argc, char *argv[]){
int mode=0;
int n = 1;
int t = 3;
int max = 10;
double *A;
double *b;
double t1;
FILE* input;
int ret = 0;
opterr = 0;
while ((ret = getopt( argc, argv, "f::g:N:t:")) != -1) {
switch (ret) {
case 'N':
if (optarg == NULL) return -1;
max = atoi(optarg);
printf("максимальный выходной размер: %d\n", max);
break;
case 't':
if (optarg == NULL) return -1;
t = atoi(optarg);
break;
case 'f':
mode = 1;
if (optarg != NULL){
printf ("ввод из файла %s\n", optarg);
if ((input = fopen (optarg, "r")) == NULL) {
perror ("невозможно открыть файл\n");
return -1;
}
} else {
printf ("ввод из файла input.txt\n");
if ((input = fopen ("input.txt", "r")) == NULL) {
perror ("невозможно открыть файл\n");
return -1;
}
}
break;
case 'g':
if (mode == 1) break;
if (optarg == NULL) return -1;
printf("ввод из функции\n");
mode = 2;
n = atoi(optarg);
printf("матрица размера: %d\n", n);
break;
case '?':
printf("неизвестная опция -%c\n", optopt);
printf("поддерживаемые опции:\n");
printf("f - ввод матрицы из файла, являющегося аргументом, или, если аргумента нет, ввод матрицы из файла input.txt;\n");
printf("g - ввод матрицы из функции. Аргумент функции (обязателен) является размером матрицы;\n");
printf("t - количество нитей;\n");
printf("N - максимальный выходной размер.\n");
return -1;
}
}
printf("Используется %d нитей.\n", t);
if (mode == 1){
if(fscanf (input, "%d", &n) == 0){
printf ("не получилось сосканировать размер матрицы из файла\n");
return -1;
}
A = new double [n*(n+1)];
if (A == NULL){
printf("не удалось выделить память под матрицу А\n");
return -1;
}
if (file_input(input, n, A) != 0){
return -1;
}
fclose(input);
} else if (mode == 2){
A = new double [n*(n+1)];
if (func_input(A, n) != 0){
return -1;
}
} else {
printf("Требуется запустить программу с какими-либо параметрами\n");
printf("Поддерживаемые параметры запуска:\n");
printf("f - ввод матрицы из файла, являющегося аргументом, или, если аргумента нет, ввод матрицы из файла input.txt;\n");
printf("g - ввод матрицы из функции. Аргумент функции (обязателен) является размером матрицы;\n");
printf("t - количество нитей;\n");
printf("N - опция, аргумент которой (обязателен) задает максимальный выходной размер.\n");
return -1;
}
pthread_t *threads = new pthread_t [t]; //инициализируем нити, выделяем под них память
if (threads == NULL){
printf("не удалось выделить память под массив нитей\n");
return -1;
}
b = new double [n];
if (b == NULL){
printf("не удалось выделить память под вектор b\n");
return -1;
}
for (int z=0;z<n;z++){
b[z] = -A[z*(n+1)+n];
}
int MAX_OUTPUT_SIZE = 10;
PrintMatrix(n, A, b, MAX_OUTPUT_SIZE);
delete []b;
printf("\n");
FILE *out;
out = fopen("output.txt", "wr");
if(out == NULL){
printf("не могу открыть выходной файл\n");
return -1;
}
double *x = new double [n]; //сюда пишем решение
if (x == NULL){
printf("не удалось выделить память под вектор x\n");
return -1;
}
double *E = new double [(n+1)*(n+1)]; //здесь будут храниться базисы
if (E == NULL){
printf("не удалось выделить память под матрицу Е\n");
return -1;
}
solve *args = new solve [t]; //массив структур для нитей
if (args == NULL){
printf("не удалось выделить память под аргументы нитей\n");
return -1;
}
double *v = new double [n+1]; //сюда запоминается вектор для master
if (v == NULL){
printf("не удалось выделить память под вектор v\n");
return -1;
}
printf("\nрешение системы...\n");
t1 = get_full_time(); //get_full_time для счета астрономического времени
Solve(n,A,x,t,threads,E,args,v);
t1 = get_full_time() - t1;
Nevyaska * arg = new Nevyaska [t];
if (args == NULL){
printf("не удалось выделить память под структуру значений для невязки\n");
return -1;
}
printf("\n");
file_output(out,n,max,x);
printf("время решения системы = %f\n", t1);
printf("\nподсчет невязки...\n");
printf("невязка = %e\n", nev(n,A,x,t,threads,arg));
if (mode == 2){
printf("норма погрешности = %e\n", error_rate(n,x));
}
delete []A;
delete []x;
delete []E;
delete []v;
delete []args;
delete []threads;
delete []arg;
fclose(out);
return 0;
}
int main(int argc, char * argv[])
{
pthread_t *tid;//number of thread
args *arg;
int total_processes;
double *a, *b, *x;
int res1, res2;
long int t;
int n;
int N;
int i;
char * filename = 0;
const char * name = "c.txt";
if( argc != 3 && argc != 4 )
{
printf("Usage : %s <n> <total_processes> <filename>\n", argv[0]);
return 0;
}
n = atoi(argv[1]);//from number to string
total_processes = atoi (argv[2]);
if(!n || !total_processes)
{
printf("Usage : %s <n> <total_processes> <filename>\n", argv[0]);
return 0;
}
a = new double[n*n];
b = new double[n];
x = new double[n];
tid = new pthread_t[total_processes];
arg = new args[total_processes];
if(argc > 3)
filename = argv[3];
if(filename)
{
res1 = read_matrix(a, n, "a.txt");
res2 = read_vector(b, n, "b.txt");
if(res1 || res2)
{
printf("cannot read from file\n");
delete [] tid;
delete [] arg;
delete [] a;
delete [] b;
delete [] x;
return 1;
}
}
else
{
init_matrix(a, n);
init_vector(b, a, n);
}
printf("matrix A:\n");
print_matrix(a, n);
printf("vector b:\n");
print_vector(b, n);
for (i = 0; i < total_processes; i++)
{
arg[i].a = a;
arg[i].b = b;
arg[i].n = n;
arg[i].total_processes = total_processes;
arg[i].num_process = i;
arg[i].error = 0;
}
t = get_full_time ();
for (i = 0; i < total_processes; i++)
{
if (pthread_create (tid + i, 0, &thread_method_of_reflections, arg + i))
{
printf ("Cannot create thread %d\n", i);
return 2;
}
}
for (i = 0; i < total_processes; i++)
pthread_join (tid[i], 0);
back_hod(a, b, x, n);
t = get_full_time () - t;
N = (n < MAX_N) ? n : MAX_N;
printf("result : ");
for(i = 0; i < N; i++)
printf("%lg ", x[i]);
printvectorfile(x,n,name);
if(filename)
{
read_matrix(a, n, "a.txt");
read_vector(b, n, "b.txt");
printf("\nResidual = %le\nElapsed time = %Lg\n",SolutionError(n,a,b,x),(long double)t/(CLOCKS_PER_SEC));
}
else
{
init_matrix(a, n);
init_vector(b, a, n);
printf("\nResidual = %le\nError = %le\nElapsed time = %Lg\n",SolutionError(n,a,b,x), SolutionAccuracy(n,x),(long double)t/(CLOCKS_PER_SEC));
}
delete [] tid;
delete [] arg;
delete [] a;
delete [] b;
delete [] x;
return 0;
}
