package performance;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.atomic.AtomicReference;

import org.apache.commons.math3.stat.descriptive.SummaryStatistics;

import collection.Stack;

public class Main
{
    public static final long NANO_PER_SECOND = 1000000000L;
    public static final AtomicReference<Long> start = new AtomicReference<Long>();

    public static void main(String[] args)
    {
        final int TRAILS = 13;
        final int SKIP = 0;

        try
        {
            final double percentage = Double.parseDouble(args[1]);
            final int threads = Integer.parseInt(args[2]);

            final CyclicBarrier barrier = new CyclicBarrier(threads + 1);
            final SummaryStatistics statistics = new SummaryStatistics();
	    final Task[] task = new Task[threads];

            for (int i = 0; i < TRAILS; i++)
            {
            	Stack<Integer> stack = (Stack<Integer>) Class.forName(args[0]).newInstance();
                Main.start.set(null);
                for (int t = 0; t < threads; t++)
                {
                    task[t] = new Task(stack, percentage, barrier, t);
                    task[t].start();
                }

                System.gc();
                barrier.await();

                for (int t = 0; t < threads; t++)
                {
                    task[t].join();
                }

                if (i >= SKIP)
                {
                    long end = 0;
                    long operations = 0;
                    for (int t = 0; t < threads; t++)
                    {
                        end = Math.max(end, task[t].getEnd());
                        operations += task[t].getOperations();
                    }

                    double throughput = operations / ((end - Main.start.get()) / (double) Main.NANO_PER_SECOND);
                    //System.out.println(throughput);
                    statistics.addValue(throughput);
                }
            }

            System.out.printf("%d,%d\n", (int) statistics.getMean(), (int) statistics.getStandardDeviation());
        }
        catch (InstantiationException | IllegalAccessException | ClassNotFoundException | InterruptedException | BrokenBarrierException e)
        {
            e.printStackTrace();
        }
    }
}