/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package mulitcoretest;

import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 *
 * @author karlssoj
 */
public class Main
{

    /**
     * @param args the command line arguments
     */

    static int tabb[];
    static int tabb1[];
    static int tabb2[];

    public static void main(String[] args) throws InterruptedException, ExecutionException
    {
        tabb = new int[10000];
        tabb1 = new int[tabb.length/2];
        tabb2 = new int[tabb.length/2];
        if((tabb.length) % 2 != 0) tabb2 = new int[tabb.length/2 + 1];

        //sparar ett slumtal 0-999 i varje tabellelement
        Random r = new Random();
        for(int i = 0; i < tabb.length; i++) tabb[i] = r.nextInt(1000);

        //visar tabellens innehåll före sortering
        //visaTabell();

        //startar tidtagning
        long  start = System.currentTimeMillis();

        //sorterar tabellen antingen i en tråd, eller parallellt i två trådar
        //(kommentera bort en av följande metodanrop)
        //singelSortering();  /* sorteringen körs på en processorkärna */
        dualSortering();  /* sorteringen körs på två processorkärnor (förutsatt att det finns två eller flera kärnor) */

        //visar hur lång tid sorteringen tog
        System.out.println("Sorteringen tog " + (System.currentTimeMillis() - start) + " millisekunder");        

        //visar sorterade tabellens innehåll
        //visaTabell();
    }

    static void visaTabell()
    {
        System.out.println("Tabellens innehåll:");

        for(int i = 0; i < tabb.length; i++)
        {
            System.out.println(tabb[i]);
        }
    }

    static void dualSortering() throws InterruptedException, ExecutionException
    {
        //splittar upp den ursprungliga tabellen i två halvor
        parallelsort.split(tabb, tabb1, tabb2);

        //skapar en trådgrupp med två "worker threads"
        parallelsort.skapaThreadPool(2);

        //sorterar båda halvorna skilt för sej i var sin tråd
        //huvudtråden väntar på att "arbetartrådarna" skall avsluta
        new parallelsort(tabb1).startaTrad().get();
        new parallelsort(tabb2).startaTrad().get();

        //förenar de två sorterade tabellhalvorna till den ursprungliga tabellen
        parallelsort.forena(tabb1, tabb2, tabb);

        //stänger av trådgruppen
        parallelsort.avsluta();
    }

    static void singelSortering()
    {
        //sorterar hela den ursprungliga tabellen i en tråd
        new parallelsort(tabb).sort();
    }
}

class parallelsort implements Runnable
{
    int tabb[];
    static ExecutorService tr;

    public parallelsort(int []tabb)
    {
        this.tabb = tabb;
    }

    static void avsluta()
    {
        tr.shutdownNow();
    }

    static void skapaThreadPool(int antal)
    {
         tr = Executors.newFixedThreadPool(antal);
    }

    static void split(int tabb[], int tabb1[], int tabb2[])
    {
        for(int i = 0, j = 0; i < tabb.length; i++)
        {
            if(i < tabb.length/2) tabb1[i] = tabb[i];

            else
            {
                tabb2[j] = tabb[i];
                j++;
            }
        }
    }

    static void forena(int tabb1[], int tabb2[], int tabb[])
    {
        for(int i = 0, i1 = 0, i2 = 0; i < tabb.length; i++)
        {
            if(tabb1[i1] < tabb2[i2])
            {
                tabb[i] = tabb1[i1];
                if(i1 < tabb1.length - 1) i1++;
                else tabb1[i1] = tabb2[i2] + 1;
            }
            else
            {
                tabb[i] = tabb2[i2];
                if(i2 < tabb2.length - 1) i2++;
                else tabb2[i2] = tabb1[i1] + 1;
            }
        }
    }

    public Future startaTrad()
    {
         return(tr.submit(this));
    }

    public void sort()
    {
        for(int i = 0; i < tabb.length; i++)
        {
            for(int j = 0; j < tabb.length - 1; j++)
            {
                if(tabb[j] > tabb[j + 1])
                {
                    int temp = tabb[j];
                    tabb[j] = tabb[j+1];
                    tabb[j+1] = temp;
                }
            }
        }
    }

    public void run()
    {
       sort();
    }
}