package be.ac.vub.ir.multithreading;

import java.util.Random;
import java.util.Vector;

import javax.swing.JFrame;

import be.ac.vub.ir.data.Chart;
import be.ac.vub.ir.data.ChartOptions;
import be.ac.vub.ir.data.XYRawData;
import be.ac.vub.ir.util.Chrono;
import edu.cmu.tetrad.data.LongColumn;
import flanagan.math.Fmath;

public class MatrixMultiplication {

	public static void main(String[] args) {
		oneComparison(300, 10, 10, true);
//		varyThreads(150, 5, 100);
//		varyMatrixSize(4, 5, 500);
	}
	public static double oneComparison(final int N, final int NBR_EXPS, final int NBR_THREADS, final boolean PRINT ) {
		if (PRINT) System.out.println("  == "+N+" X "+N+" Matrices " +NBR_EXPS+" exps == ");
		
		if (PRINT) System.out.println("Sequential:");
		LongColumn col = new LongColumn("computation times");
		for(int i=0;i<NBR_EXPS;i++){
			col.add(measure(new MatrixRbR(N, N), new MatrixCbC(N, N)));
		}
		if (PRINT) System.out.println("RbR x RbR: Avg runtime = "+ ((long)col.mean()) + " min = "+((long)col.min())+" stddev = "+((long)col.stddev()));
		
		if (PRINT) System.out.println("Parallel:");
		LongColumn col2 = new LongColumn("computation times");
		for(int i=0;i<NBR_EXPS;i++){
			col2.add(measureParallel(new MatrixRbR(N, N), new MatrixCbC(N, N), NBR_THREADS));
		}
		if (PRINT) System.out.println("RbR x RbR: Avg runtime = "+ ((long)col2.mean()) + " min = "+((long)col2.min())+" stddev = "+((long)col2.stddev()));
		
		double speedup = col.mean()/ col2.mean();
		
		// with this code you just do 1 run
//		long SeqT = measure(new MatrixRbR(N, N), new MatrixCbC(N, N));
//		long parT = measureParallel(new MatrixRbR(N, N), new MatrixCbC(N, N), NBR_THREADS);
//		double speedup = (double)SeqT/parT;
		
		if (PRINT) System.out.println(" ==> Speedup = "+Fmath.truncate(speedup, 3));
		return speedup;
	}
	public static void varyThreads(final int N, final int NBR_EXPS, final int MAX_THREADS){
		XYRawData data = new XYRawData("Nbr Threads","#", "Speedup", "");
		data.add(1, 1);
		
		for(int t=2;t<MAX_THREADS;t++){
			double speedup = oneComparison(N, NBR_EXPS, t, true);
			data.add((float)t, (float)speedup);
		}
		Chart graph = new Chart(new ChartOptions(data));
		graph.chartOptions().mShowCorrelation = false;
		graph.showInFrame().setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
	public static void varyMatrixSize(final int NBR_THREADS, final int NBR_EXPS, final int MAX_N){
		XYRawData data = new XYRawData("Matrix Size","#", "Speedup", "");
		data.add(1, 1);
		
		for(int n=50;n<MAX_N;n+=50){
			double speedup = oneComparison(n, NBR_EXPS, NBR_THREADS, true);
			data.add((float)n, (float)speedup);
		}
		Chart graph = new Chart(new ChartOptions(data));
		graph.chartOptions().mShowCorrelation = false;
		graph.showInFrame().setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
	public static long measure(Matrix A, Matrix B){
		A.fillRandomly();
		B.fillRandomly();
		Chrono c = new Chrono();
		multiplication(A, B);
		c.stop();
		return c.elapsedtime();
	}
	
	public static long measureParallel(Matrix A, Matrix B, final int NBR_THREADS){
		A.fillRandomly();
		B.fillRandomly();
		Chrono c = new Chrono();
		multiplicationParallel(A, B, NBR_THREADS);
		c.stop();
		return c.elapsedtime();
	}
	// *** PARALLEL SOLUTION ***
	public static Matrix multiplicationParallel(final Matrix A, final Matrix B, final int NBR_THREADS){
		if (A.cols != B.rows)
			throw new IllegalArgumentException("A and B should match");
		
		final Matrix C = new MatrixRbR(A.rows, B.cols);
		Vector<Thread> threads = new Vector<Thread>();
	
		final int NBR_ROWS = A.rows, NBR_COLUMNS = B.cols;
		
		for(int i=0; i<NBR_THREADS; i++)
		{
			final int I = i;
			Thread thr = new Thread(){
				public void run(){
					int k=I;
					while(k<NBR_ROWS*NBR_COLUMNS){
						int r = k/NBR_ROWS;
						int c = k%NBR_COLUMNS;
						int sum = 0;
						for(int l=0;l<A.cols;l++){
							sum+=A.get(r, l) * B.get(l, c);
						}
						C.set(sum, r, c);
						k += NBR_THREADS;
					};
				}
			};
			thr.start();
			threads.add(thr);
		}

		for(Thread th : threads){
			try {
				th.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		return C;
	}
	// *** SEQUENTIAL SOLUTION ***
	public static Matrix multiplication(Matrix A, Matrix B){
		if (A.cols != B.rows)
			throw new IllegalArgumentException("A and B should match");
		
		Matrix C = new MatrixRbR(A.rows, B.cols);
		for(int r=0;r<A.rows;r++)
		{
			for(int c=0;c<B.cols;c++){
				int sum=0;
				for(int k=0;k<A.cols;k++)
					sum+=A.get(r, k) * B.get(k, c);
				C.set(sum, r, c);
			}
		}
		return C;
	}
	public static void fillRandomly(Matrix m){
		Random rand = new Random();
		for(int r=0;r<m.rows;r++)
			for(int c=0;c<m.cols;c++)
				m.set(rand.nextInt(100000)-50000, r, c);
	}
}
abstract class Matrix{
	int rows, cols;
	int[] data;
	
	Matrix(int rows, int cols){
		this.rows = rows;
		this.cols = cols;
		data = new int[rows*cols];
	}
	
	abstract int get(int row, int col);
	protected int get(int i){ return data[i]; }
	abstract void set(int val, int row, int col);
	abstract String method();
	void fillRandomly(){
		Random rand = new Random();
		for(int r=0;r<rows;r++)
			for(int c=0;c<cols;c++)
				set(rand.nextInt(100000)-50000, r, c);
	}
}
class MatrixRbR extends Matrix{

	MatrixRbR(int rows, int cols){
		super(rows, cols);
	}
	int get(int row, int col){
		return data[row * cols + col]; }
	void set(int val, int row, int col){ data[row * cols + col] = val; }
	String method(){ return "RbR"; }
}
class MatrixCbC extends Matrix{

	MatrixCbC(int rows, int cols){
		super(rows, cols);
	}
	int get(int row, int col){
		return data[row + col * rows]; }
	void set(int val, int row, int col){ data[row + col * rows] = val; }
	String method(){ return "CbC"; }
}