import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;
import easyIO.*;
// file: Modell3.java - enklere, men ogs? litt langsommere versjon av Modell2.java
// Lagt ut 10 feb 2017.Korrigert: Arne Maus, Ifi, UiO

class Modell3{
	// ****** Problemets FELLES DATA HER
	int i;
	final String navn = "TEST AV i++ med synchronized oppdatering som eksempel";

	 // Felles system-variable - samme for 'alle' programmer
	 int antTraader;
	 int antKjerner;
	 int numIter ;          // antall ganger for ? lage median (1,3,5,,)
	 int nLow,nStep,nHigh;  // laveste, multiplikator, hoyeste n-verdi
	 int n;	                // problemets st?rrelse
	 String filnavn;
	 int med;
	 Out ut;

	 double [] seqTime ;
	 double [] parTime ;
	 Thread [] traadene;

	 /** for ogs? utskrift p? fil */
	 synchronized void println(String s) {
		 ut.outln(s);
		 System.out.println(s);
	 }

	 /** for ogs? utskrift p? fil */
	 synchronized void print(String s) {
		 ut.out(s);
		 System.out.print(s);
	 }

	 /** initieringen i main-tr?den */
	 void intitier(String [] args) {
			nLow = Integer.parseInt(args[0]);
			nStep = Integer.parseInt(args[1]);
			nHigh = Integer.parseInt(args[2]);
			numIter = Integer.parseInt(args[3]);
		    filnavn = args[4];
		     seqTime = new double [numIter];
		     parTime = new double [numIter];
		     ut = new Out(filnavn, true);

			 antKjerner = Runtime.getRuntime().availableProcessors();
			 antTraader = antKjerner;
			 traadene = new Thread[antTraader];
	} // end initier


	public static void main (String [] args) {
		if ( args.length != 5)	{
			System.out.println("use: >java Modell3 <nLow> <nStep> <nHigh> <num iterations> <fil>");
	    } else {
		    new Modell3().utforTest(args);
	    }
	 } // end main


	 void  utforTest (String [] args) {
		intitier(args);
	    println("Test av  "+ navn+ "\n med "+
	              antKjerner + " kjerner , og " + antTraader+" traader,  Median av:" + numIter+" iterasjoner\n");
	    println("\n     n      sekv.tid(ms)   para.tid(ms)    Speedup ");

        for (n = nHigh; n >= nLow; n=n/nStep) {
		    for (med = 0; med < numIter; med++) {

				 //  ****** KALL PAA DIN  parallelle l?sning  (er i traadene)  ***** ;
				 long t = System.nanoTime();  // start tidtagning parallell
			     // start traadene
			     for (int i = 0; i< antTraader; i++)
		 		      (traadene[i] =new Thread(new Para(i,n))).start();
		 		  // vent paa tr?dene er ferdige
			      for (int i = 0; i< antTraader; i++)
			       try{    traadene[i].join();} catch (Exception e) { return;}
				 t = (System.nanoTime()-t);
				 parTime[med] =t/1000000.0;


				 t = System.nanoTime(); // start tidtagning sekvensiell
				 //**** KALL PAA DIN SEKVENSIELLE METODE  H E R ********
				 sekvensiellMetode (n);
				 t = (System.nanoTime()-t);
				 seqTime[med] =t/1000000.0;

		    } // end for med

		    println(Format.align(n,10)+
		         Format.align(median(seqTime,numIter),12,3)+
			     Format.align(median(parTime,numIter),15,3)+
			     Format.align(median(seqTime,numIter)/median(parTime,numIter),13,4));

	    } // end n-llop
         ut.close();

	 } // utforTest


     /*** HER er din egen sekvensielle metode
          som  selvsagt IKKE ER synchronized, */
	 void sekvensiellMetode (int n){
		 i=0;
		 for (int j=0; j<n; j++){
		 	  i++;
		 }
     } // end sekvensiellMetode

     /*** HER er evt. de av de  parallelle metodene som ER synchronized, langsom */
	 synchronized void addI(int minI) {
	 		  i+= minI ;
	  }

	 class Para implements Runnable{
		   int ind, fra,til,num;
		   int minI = 0;        // lokale data for problemet
		   Para(int in, int n) {
			   ind =in;
			   num = n/antTraader;
			   fra = ind*num;
			   til = (ind+1)*num;
			   if (ind == antTraader-1) til =n;
			 } // konstruktor


	       /*** HER er dine  parallelle metoder som IKKE er synchronized */
		    void  parallellMetode() {
		   		 for (int j=fra; j<til; j++){
		   		    minI++;
				}
	        } // end parallellMetode

	        public void run() { // Her er det som kjores i parallell:
			      //**** KALL P? DINE PARALLELLE METODER  H E R ********
			       parallellMetode();
				  // Alle traadene kaller en synkronisert metode for oppdatering av globale data
			       addI(minI);
			} // end run
     } // end class Para

	 /** sort double-array a to find median */
	 double median(double a[], int right) {
				int i,k;
				double t;

				for (k = 1 ; k < right; k++) {
					t = a[k] ;
					i = k;

					while ((a[i-1] ) > t ) {
						 a[i] = a[i-1];
						 if (--i == 0) break;
					}
					a[i] = t;
				} // end k
				return (a[a.length/2]);
	 } // end insertSort
}// END class Parallell