import java.util.Collections;
import java.util.Random;
import java.util.concurrent.Phaser;
import java.util.Collections;

public class OneDimAveragingPhaser {
    int n;
    double[] myVal;
    double[] myNew;

    OneDimAveragingPhaser(int n) {
        this.n = n;
        myVal = new double[n + 2];
        Random random = new Random(System.currentTimeMillis());
        for (int i = 1; i < n; ++i)
            myVal[i] = random.nextInt(300);
        myVal[0] = myVal[1] = 0;

        myNew = new double[n + 2];
    }

    public void runSequential(final int iterations) {
        long startTime = System.nanoTime();

        for (int i = 0; i < iterations; ++i) {
            for (int j = 1; j < n; ++j) {
                myNew[j] = (myVal[j - 1] + myVal[j + 1]) / 2.0;
            }
            myVal = myNew;
        }
        
        long timeInNanoSec = System.nanoTime() - startTime;
        printResults("runSequential", timeInNanoSec);
    }

    public void runForAllBarrier(final int iterations, final int tasks) {
        Phaser ph = new Phaser(0);
        ph.bulkRegister(tasks);

        Thread[] threads = new Thread[tasks];

        for (int ii = 0; ii < tasks; ++ii) {
            int i = ii;
            threads[ii] = new Thread(() -> {
                double[] myVal = this.myVal;
                double[] myNew = this.myNew;

                for (int iter = 0; iter < iterations; ++iter) {
                    // Identify leftmost boundary element for group
                    int left = i * (n / tasks) + 1;
                    
                    // Identify the rightmost boundary element for group
                    int right = (i + 1) * (n / tasks);

                    // Iterate through all the elements of the group
                    for (int j = left; j <= right; ++j)
                        myNew[j] = (myVal[j - 1] + myVal[j + 1]) / 2.0;

                    ph.arriveAndAwaitAdvance();  // barrier

                    myVal = myNew;
                }
            });
            
            threads[ii].start();
        }
    }

    // Split the Phaser into arrive and awaitAdvance stages.
    public void runForAllFuzzyBarrier(final int iterations, final int tasks) {
        Phaser ph = new Phaser(0);
        ph.bulkRegister(tasks);

        Thread[] threads = new Thread[tasks];

        for (int ii = 0; ii < tasks; ++ii) {
            int i = ii;
            threads[ii] = new Thread(() -> {
                double[] myVal = this.myVal;
                double[] myNew = this.myNew;

                for (int iter = 0; iter < iterations; ++iter) {
                    // Identify leftmost boundary element for group
                    int left = i * (n / tasks) + 1;
                    myNew[left] = (myVal[left - 1] + myVal[left + 1]) / 2.0;
                    
                    // Identify the rightmost boundary element for group
                    int right = (i + 1) * (n / tasks);
                    myNew[right] = (myVal[right - 1] + myVal[right + 1]) / 2.0;

                    // Now the phaser has finished the shared task, thus it can signal that it has arrived.
                    int currentPhase = ph.arrive();

                    // Now it can do some local task, this task doesn't depend on any other task.
                    for (int j = left + 1; j <= right - 1; ++j)
                        myNew[j] = (myVal[j - 1] + myVal[j + 1]) / 2.0;

                    ph.awaitAdvance(currentPhase);  // wait

                    myVal = myNew;
                }
            });
            
            threads[ii].start();
        }
    }

    public static void main(String[] args) {
        // clear the screen.
        System.out.print("\033[H\033[2J");
        System.out.flush();
        
        int tasks = 4;
        int n = 100000;
        int iterations = 10000;
        int rounds = 5;

        System.out.println("Configuration : ");
        System.out.println("  # of tasks for parallel run: " + tasks);
        System.out.println("  Array size n: " + n);
        System.out.println("  # iterations: " + iterations);
        System.out.println("  Rounds: " + rounds);
        System.out.println("\n\n");

        OneDimAveragingPhaser averagingPhaser = new OneDimAveragingPhaser(n);
 
        for (int i = 0; i < rounds; ++i) {
            System.out.println("Run " + (i + 1));
            averagingPhaser.runSequential(iterations);
            averagingPhaser.runForAllBarrier(iterations, tasks);
            averagingPhaser.runForAllFuzzyBarrier(iterations, tasks);
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        System.out.println("\n");
    }

    private static void printResults(String name, long time) {
        System.out.printf("   %18s Time: %8.3f ms. \n", name, time / 1e6);
    }
}