/*******************************************************************************
 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
 * in Industry THTH ry.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     VTT Technical Research Centre of Finland - initial API and implementation
 *******************************************************************************/
package org.simantics.db.tests.performance.java;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Semaphore;

import org.simantics.db.testing.base.TestCommonPerf;


/**
 *
 */
public class SynchronizationTest extends TestCommonPerf {

//	public void test() throws Exception {
//
//		class CounterThread extends Thread {
//
//			final private Semaphore start;
//			final private AtomicInteger counter;
//			final private CountDownLatch latch;
//			
//			public CounterThread(Semaphore start, CountDownLatch latch, AtomicInteger counter) {
//				this.start = start;
//				this.counter = counter;
//				this.latch = latch;
//			}
//			
//			@Override
//			public void run() {
//				
//				try {
//					start.acquire();
//				} catch (InterruptedException e) {
//					e.printStackTrace();
//				}
//
//				int work = 0;
//				for(int i=0;i<10000000;i++) {
//					counter.incrementAndGet();
//					for(int j=0;j<100;j++) work++;
//					counter.decrementAndGet();
//				}
//				
//				latch.countDown();
//				
//				System.out.println("work=" + work);
//				
//			}
//			
//		}
//		
//		CountDownLatch latch = new CountDownLatch(8);
//		AtomicInteger counter = new AtomicInteger(0);
//		Semaphore starter = new Semaphore(0);
//		
//		for(int i=0;i<8;i++) new CounterThread(starter, latch, counter).start();
//		
//		Thread.sleep(500);
//
//		starter.release(8);
//		long start = System.nanoTime();
//		latch.await();
//		long duration = System.nanoTime() - start;
//
//		System.out.println("counter=" + counter.get());
//		
//		System.out.println("Finished in " + 1e-9*duration + "s.");
//		
//	}
//
//	public void test2() throws Exception {
//
//		class CounterThread extends Thread {
//
//			final private int index;
//			final private Semaphore start;
//			final private AtomicIntegerArray counter;
//			final private CountDownLatch latch;
//			
//			public CounterThread(int index, Semaphore start, CountDownLatch latch, AtomicIntegerArray counter) {
//				this.index = index;
//				this.start = start;
//				this.counter = counter;
//				this.latch = latch;
//			}
//			
//			@Override
//			public void run() {
//				
//				try {
//					start.acquire();
//				} catch (InterruptedException e) {
//					e.printStackTrace();
//				}
//
//				for(int i=0;i<50000000;i++) {
//					counter.incrementAndGet(index);
//				}
//				
//				latch.countDown();
//				
//			}
//			
//		}
//		
//		CountDownLatch latch = new CountDownLatch(4);
//		AtomicIntegerArray counter = new AtomicIntegerArray(4);
//		Semaphore starter = new Semaphore(0);
//		
//		for(int i=0;i<4;i++) new CounterThread(i, starter, latch, counter).start();
//		
//		Thread.sleep(500);
//
//		starter.release(4);
//		long start = System.nanoTime();
//		latch.await();
//		long duration = System.nanoTime() - start;
//
//		//System.out.println("counter=" + counter.get());
//		
//		System.out.println("[counter=" + counter + "]: Finished in " + 1e-9*duration + "s.");
//		
//	}
//	
//	public void test3() throws Exception {
//
//		class CounterThread extends Thread {
//
//			final private int index;
//			final private Semaphore start;
//			final private AtomicInteger counter;
//			final private CountDownLatch latch;
//			
//			public CounterThread(int index, Semaphore start, CountDownLatch latch, AtomicInteger counter) {
//				this.index = index;
//				this.start = start;
//				this.counter = counter;
//				this.latch = latch;
//			}
//			
//			@Override
//			public void run() {
//				
//				try {
//					start.acquire();
//				} catch (InterruptedException e) {
//					e.printStackTrace();
//				}
//
//				for(int i=0;i<50000000;i++) {
//					counter.incrementAndGet();
//				}
//				
//				latch.countDown();
//				
//			}
//			
//		}
//		
//		CountDownLatch latch = new CountDownLatch(4);
//		AtomicInteger counter = new AtomicInteger(0);
//		Semaphore starter = new Semaphore(0);
//		
//		for(int i=0;i<4;i++) new CounterThread(i, starter, latch, counter).start();
//		
//		Thread.sleep(500);
//
//		starter.release(4);
//		long start = System.nanoTime();
//		latch.await();
//		long duration = System.nanoTime() - start;
//
//		//System.out.println("counter=" + counter.get());
//		
//		System.out.println("[counter=" + counter + "]: Finished in " + 1e-9*duration + "s.");
//		
//	}

	public void test4() throws Exception {

		int size = 50000000;

		for(int i=0;i<2;i++) {
			runTest3(1, size, 4);
			runTest3(2, size, 4);
			runTest3(4, size, 4);
			runTest3(8, size, 4);
			runTest3(16, size, 4);
			runTest3(32, size, 4);
			runTest3(64, size, 4);
			runTest3(128, size, 4);
			runTest3(256, size, 4);
			runTest3(512, size, 4);
		}
		
	}
	
	private void runTest3(final int STRIPE, final int size, final int threads) throws Exception {
		
		final int[] work = new int[STRIPE*threads];
		
		class CounterThread extends Thread {

			final private int index;
			final private Semaphore start;
			final private CountDownLatch latch;
			
			public CounterThread(int index, Semaphore start, CountDownLatch latch) {
				this.index = index;
				this.start = start;
				this.latch = latch;
			}
			
			@Override
			public void run() {
				
				try {
					start.acquire();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
				int offset = STRIPE*index;

				for(int i=0;i<size;i++) work[offset]++; 
				
				latch.countDown();
				
			}
			
		}
		
		CountDownLatch latch = new CountDownLatch(threads);
		Semaphore starter = new Semaphore(0);
		
		for(int i=0;i<threads;i++) new CounterThread(i, starter, latch).start();
		
		Thread.sleep(500);
		
		starter.release(threads);
		long start = System.nanoTime();
		latch.await();
		long duration = System.nanoTime() - start;

		int sum = 0;
		for(int i=0;i<STRIPE*threads;i++) sum += work[i];
		
//		System.out.println("work=" + sum);

		
		//System.out.println("counter=" + counter.get());
		
		System.out.println("[STRIPE=" + STRIPE + ", work=" + sum + "]: Finished in " + 1e-9*duration + "s.");
		
	}
	
}