// matrix multiplication using threads

public class mm1
{
    // find out number of physical cores/processors available.
  static int cores  = Runtime.getRuntime().availableProcessors();

    // conventional solution, assume square matrix for simplicity.
    static void mm0(double[][] A, double[][] B, double[][] R) // writes to R
    {
	int N = A.length; // assume same as A[0].length, B.length, R.length, etc
	
	for(int i = 0;i<N;i++)
	    for(int j=0;j<N;j++)
		{
		    R[i][j] = 0;
		    for(int k=0;k<N;k++)
			R[i][j] += A[i][k] * B[k][j];
		}
    }//mm0

    public static void randomize(double[][] A, int N) // generate NxN array
    {
	for(int i = 0;i<N;i++)
	    for(int j=0;j<N;j++)
		{ A[i][j]=Math.random(); }
    }

    public static void main(String[] av) 
    {
	int N = 1000; // default array size;
	if (av.length>0) N = Integer.parseInt(av[0]);
	// create arrays
	double[][] A = new double[N][N];
	double[][] B = new double[N][N];
	double[][] R = new double[N][N];
	randomize(A,N);  randomize(B,N);

	// testing conventional solution
	long t1 = System.currentTimeMillis(); // record time	
	mm0(A,B,R);
	long t2 = System.currentTimeMillis(); // record time
	System.out.println("conventional solution time: "+(t2-t1)+"ms");

	System.out.println("number of CPU cores: "+cores); System.out.flush();
	t1 = System.currentTimeMillis(); // record time for threaded solution
	
    try {
	// create worker threads
	Thread[] Ts = new Thread[cores]; // keep track of threads created.
	int Rs = N/cores; // number of rows to assign to each thread
	for(int w=0;w<cores;w++)
	    {
		int Ra = Rs; // rows assigned 
		if (w==cores-1) // last thread may get more rows
		    Ra += N%cores;
		workercore wc = new workercore(A,B,R,Rs*w,Ra);
		Ts[w] = new Thread(wc);
		Ts[w].start(); // start right away
	    }
	for(int w=0;w<cores;w++) Ts[w].join(); // wait for each to finish
    } catch (InterruptedException ie) {System.out.println(ie); System.exit(1);}
    
	t2 = System.currentTimeMillis(); // record time
	System.out.println("time for multi-threaded solution: "+(t2-t1)+"ms");
    }//main

}//mm1 class

class workercore implements Runnable
{
    double[][] A;  // pointer to external matrices, AXB = R
    double[][] B;
    double[][] R;
    int start, N; // starting row and number of rows.
    public workercore(double[][] a, double[][] b, double[][] c, int s, int n)
    {A=a; B=b; R=c; start=s; N=n;}

    public void run()
    {
	int Cols = A[0].length;
	for(int i = start;i<N+start && i<Cols;i++)
	    for(int j=0;j<Cols;j++)
		{
		    R[i][j] = 0;
		    for(int k=0;k<Cols;k++)
			R[i][j] += A[i][k] * B[k][j];
		}	
    }
}//workercore