/*******************************************************************************
 * 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 gnu.trove.map.hash.TIntIntHashMap;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

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


public class SynchronizedAccessTest extends TestCommonPerf {

	public void perform3(int threads) throws InterruptedException {

		final Lock lock = new ReentrantLock(false);
		final TIntIntHashMap map = new TIntIntHashMap();
		
		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();
				}
				
				for(int i=0;i<1000000;i++) {
					lock.lock();
					map.put(i, i);
					lock.unlock();
				}
				
				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;
		System.err.println("took " + 1e-9*duration);
		
	}

	public void perform2(int threads) throws InterruptedException {

		final TIntIntHashMap map = new TIntIntHashMap();
		
		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();
				}
				
				for(int i=0;i<1000000;i++) {
					synchronized(map) {
						map.put(i, i);
					}
				}
				
				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;
		System.err.println("took " + 1e-9*duration);
		
	}

	public void perform(int threads) throws InterruptedException {

		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();
				}

				final TIntIntHashMap map = new TIntIntHashMap();
				
				for(int i=0;i<1000000;i++) {
					synchronized(map) {
						map.put(i, i);
					}
				}
				
				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;
		System.err.println("took " + 1e-9*duration);
		
	}
	
	public void test() throws Exception {

		for(int i=0;i<5;i++) perform(4);
		for(int i=0;i<5;i++) perform2(4);
		for(int i=0;i<5;i++) perform3(4);
		
	}

}