import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;
import easyIO.*;
// file: Modell2.java
// Lagt ut 12. feb 2014.Korrigert:12,13. og 14. feb - Arne Maus, Ifi, UiO
// Som BARE et eksempel, er problemet med ? ?ke fellesvariabelen i  n*antKjerner  ganger l?st

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

	 // Felles system-variable - samme for 'alle' programmer
	 CyclicBarrier vent,ferdig ; // for at tr?dene og main venter p? hverandre
	 int antTraader;
	 int antKjerner;
	 static int numIter ;          // antall ganger for ? lage median (1,3,5,,)
	 static int nLow,nStep,nHigh;  // laveste, multiplikator, hoyeste n-verdi
	 static int n;	                      // problemets st?rrelse
	 static String filnavn;
	 volatile boolean stop = false;
	 int med;
	 Out ut;

	 double [] seqTime ;
	 double [] parTime ;

	 /** 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() {
		     seqTime = new double [numIter];
		     parTime = new double [numIter];
		     ut = new Out(filnavn, true);

			 antKjerner = Runtime.getRuntime().availableProcessors();

			 antTraader = antKjerner;
			 vent   = new CyclicBarrier(antTraader+1); //+1, ogs? main
			 ferdig = new CyclicBarrier(antTraader+1); //+1, ogs? main

             // start tr?dene
             for (int i = 0; i< antTraader; i++)
		 		 new Thread(new Para(i)).start();
	} // end initier


	public static void main (String [] args) {
		if ( args.length != 5)	{
			System.out.println("use: >java Modell <nLow> <nStep> <nHigh> <num iterations> <fil>");
	    } else {
		    nLow = Integer.parseInt(args[0]);
		    nStep = Integer.parseInt(args[1]);
		    nHigh = Integer.parseInt(args[2]);
		    numIter = Integer.parseInt(args[3]);
		    filnavn = args[4];
		    new Modell2().utforTest();
	    }
	 } // end main


	void  utforTest () {
		intitier();
	    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++) {

				 long t = System.nanoTime();  // start tidtagning parallell
		         // Start alle tr?dene parallell beregning n?
				 try {
				   vent.await();   // start de parallelle tr?dene
				   ferdig.await(); // vent p? at tr?dene er ferdige
				 } catch (Exception e) {return;}
				 t = (System.nanoTime()-t);
				 parTime[med] =t/1000000.0;

				 t = System.nanoTime(); // start tidtagning sekvensiell
				 //**** KALL P? DIN SEKVENSIELLE METODE  H E R ********
				 sekvensiellMetode (n,numIter);
				 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

        stop = true;
		try {  // start the other threads and they terminate
		   vent.await();
		} catch (Exception e) {return;}

        ut.close();
	 } // utforTest


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

     /*** HER er evt. de parallelle metodene som ER synchronized */
	 synchronized void addI() {
	 		  i++;
	  }

	 class Para implements Runnable{
		   int ind;
		   Para(int i) { ind =i;} // konstruktor


	       /*** HER er dine  parallelle metoder som IKKE er synchronized */
		    void  parallellMetode(int ind) {
		   		 for (int j=0; j<n; j++){
		   		    addI();
				}
	        } // end parallellMetode

	        public void run() { // Her er det som kjores i parallell:

			   while (! stop) {
				      try {  // wait on all other threads + main
					     vent.await();
				      } catch (Exception e) {return;}

	         	      if (! stop) {

					      //**** KALL P? DINE PARALLELLE METODER  H E R ********
					      parallellMetode(ind); // parameter: traanummeret: ind

					      try{ // make all threads terminate
								ferdig.await();
					      } catch (Exception e) {}

  				      }// end stop thread
			    } // while
			} // 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