prir/DergunPiotr-WaskoDominik/zad2/macierz_mpi.cpp

#include <iostream>
#include <cstdlib>
#include <cmath>
#include "Ttiming.h"
#include <mpi.h>
#include <stdio.h>

using namespace std;

void array_alloc(long **&arr, long arrsize)
{
	try
	{	
		arr = new long* [arrsize];	
		arr[0] = new long [arrsize*arrsize];
	
		for(long i = 1; i < arrsize; ++i)
			arr[i] = arr[i-1] + arrsize;
	}
	catch (bad_alloc& ex)
	{
		cerr << "Could not allocate memory for array" << endl;
		exit(1);
	}
}

void vect_alloc(long *&arr, long arrsize)
{
	try
	{	
		arr = new long [arrsize];	
	}
	catch (bad_alloc& ex)
	{
		cerr << "Could not allocate memory for vector" << endl;
		exit(1);
	}
}

void array_destroy(long **arr)
{
	delete [] arr[0];
	delete [] arr;
}

int main(int argc, char *argv[])
{
	long **A=NULL, **B=NULL, **C=NULL, *B_rot=NULL, *vect=NULL, *vect_c=NULL, *C_rot=NULL;
	long rozmiar=0, porcja_new=0;
	char *endptr;
	TTiming tt;
	long i;
	MPI::Status  status;

	if (argc < 2)
	{
		cerr << "Usage: " << argv[0] << " <size>" << endl;
		exit(1);
	}
	
	rozmiar = strtol(argv[1], &endptr, 10);
	
	if (*endptr)
	{
		cerr << "Invalid array size format" << endl;
		exit(1);
	}	  

	if (rozmiar <= 0 || rozmiar > 2000)
	{
		cerr << "The number of matrix dimension must be in range [1,2000]" << endl;
		exit(1);
	}
	  
	MPI::Init(argc, argv);

	int taskid = MPI::COMM_WORLD.Get_rank();
	int ntasks = MPI::COMM_WORLD.Get_size();

	//alokacja macierzy
	array_alloc(A, rozmiar);
	if (taskid == 0) 
	{
		array_alloc(B, rozmiar);
		vect_alloc(B_rot, rozmiar*rozmiar);
		vect_alloc(C_rot, rozmiar*rozmiar);
	}

	// porcja - ile wektorów dostaje jeden proces do liczenia
	// jeżeli liczba procesów większa od wektorów - każdy proces dostaje po jednym, niektóre wcale
	long porcja = (rozmiar>=ntasks) ? (long)round(rozmiar*1.0/ntasks) : 1;
	porcja *= rozmiar; //porcję mnożymy przez ilość elementów w jednym wektorze
	porcja_new = porcja;
	
	array_alloc(C, rozmiar);
	vect_alloc(vect, porcja);
	vect_alloc(vect_c, porcja);
	if (taskid == 0)
	{
		// wypełnienie macierzy A liczbami "losowymi"
		for (long i=0; i<rozmiar; ++i)
			for (long j=0; j<rozmiar; ++j)
				A[i][j] = 3*i+j+1; //test
				//A[i][j] = (long)(sin(i) * i * j) % 10;
			
		// wypełnienie macierzy B liczbami "losowymi"
		for (long i=0; i<rozmiar; ++i)
			for (long j=0; j<rozmiar; ++j)
				B[i][j] = j; //test
				//B[i][j] = (long)(cos(j) *(i+j)) % 10;
				
		// dokonaj obracania macierzy
		for (long i=0; i<rozmiar; ++i)
			for (long j=0; j<rozmiar; ++j)
				B_rot[i*rozmiar+j] = B[j][i];
	}
	
	//wysyłanie macierzy A do wszystkich
	MPI::COMM_WORLD.Bcast(&A[0][0], rozmiar*rozmiar, MPI::LONG, 0);
	if (taskid == 0  && false)
	{
		cout << endl << "WEKTOR DANYCH: " << endl;
		for (i=0; i<rozmiar*rozmiar; ++i)
			cout << B_rot[i] << " ";
		cout << endl;
	}
	MPI::COMM_WORLD.Barrier();
	
	//dla wszystkich lub "rozmiar" procesów należy zadać porcję do obliczenia
	MPI::COMM_WORLD.Scatter(&B_rot[0], porcja, MPI::LONG, &vect[0], porcja, MPI::LONG,0);// (rozmiar>=ntasks) ? 0 : ntasks-rozmiar);
	
	//
	// część licząca ---------------------------------------------------------------------------------
	//
	
	MPI::COMM_WORLD.Barrier();
	if (taskid == 0)
		tt.Begin();

	if (taskid == ntasks -1) //przelicz porcję dla ostatniego procesu (w przypadku dzielenia z resztą)
	{
		porcja_new = (rozmiar - (porcja/rozmiar)*(ntasks-1))*rozmiar;
		
		// myk jest taki, że muszę podać jakąś niezerową porcję do gathera,
		// mimo, że proces nie ma żadnych (sensownych) danych do przetworzenia
		if (porcja_new > 0)
			porcja = porcja_new;
	}

	for (i=0; i<porcja_new; ++i)
	{
		vect_c[i] = 0;
		for (long k=0; k<rozmiar; ++k)
		{
			vect_c[i] += A[i%rozmiar][k]*vect[(i/rozmiar)*rozmiar+k];
		}
	}
	
	MPI::COMM_WORLD.Barrier();
	if (taskid == 0)
	{
		long elapsed = tt.End();	
		cout << "Time: " << elapsed << " ms" << endl;
	}
	
	// zwróć wszystko do programu głównego
	MPI::COMM_WORLD.Gather(&vect_c[0], porcja, MPI::LONG, &C_rot[0], porcja, MPI::LONG, 0);

	if (taskid == 0 && false)
	{
		for (i=0; i<rozmiar*rozmiar; ++i)
		{
			cout << C_rot[i] << " ";
		}
		
		cout << endl;
	}
	
	/*

	array_destroy(A);
	array_destroy(B);
	array_destroy(C);
	*/
	
	MPI::Finalize();
	
	exit(0);
}