com.venky.core.log.TimerStatistics Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of common Show documentation
Commonly used programming tasks in java
The newest version!
package com.venky.core.log;

import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.SortedSet;
import java.util.Stack;
import java.util.TreeSet;
import java.util.logging.Logger;

import com.venky.core.util.Bucket;


public class TimerStatistics {
	private final String context;
	private final Bucket callCount ;
	private final Bucket elapsedTime; 
	private TimerStatistics(String context){
		this.context = context;
		this.callCount = new Bucket();
		this.elapsedTime = new Bucket();
	}
	
	private static ThreadLocal> timerStatisticsInThread = new ThreadLocal>();
	static Map getTimerStatistics(){
		Map timerStatistics =  timerStatisticsInThread.get();
		if (timerStatistics == null){
			timerStatistics = new HashMap();
			timerStatisticsInThread.set(timerStatistics);
		}
		return timerStatistics;
	}
	
	private static ThreadLocal> timerStackInThread = new ThreadLocal>();
	static Stack getTimerStack(){
		Stack timerStack = timerStackInThread.get();
		if (timerStack == null){
			timerStack = new Stack();
			timerStackInThread.set(timerStack);
		}
		return timerStack;
	}

	
	
	private static final Logger cat = Logger.getLogger(TimerStatistics.class.getName()); 
	public String getStatistics(){
		if (!cat.isLoggable(ExtendedLevel.TIMER)){
			return "";
		}
		StringBuilder b = new StringBuilder();
		if (callCount.intValue() > 0){
			b.append(context).append("|").append(callCount.intValue()).append("|").append(elapsedTime.value()).append("|").append(elapsedTime.value()/callCount.intValue());
		}
		return b.toString();
	}
	
	
	public static void dumpStatistics(){
		if (!cat.isLoggable(ExtendedLevel.TIMER)){
			return;
		}
		Map timers = getTimerStatistics();
		Iterator i = timers.keySet().iterator();
		SortedSet out = new TreeSet(new Comparator() {

			public int compare(TimerStatistics o1, TimerStatistics o2) {
				return o2.elapsedTime.intValue() - o1.elapsedTime.intValue();
			}
		});
		while (i.hasNext()){
			String e = i.next();
			TimerStatistics t = timers.get(e);
			if (t.callCount.intValue() > 0 ){
				out.add(t);
			}
			i.remove();
		}
		cat.log(ExtendedLevel.TIMER, "--------Timings Dumped-----------");
		for (TimerStatistics s:out){
			cat.log(ExtendedLevel.TIMER, s.getStatistics());
		}
		cat.log(ExtendedLevel.TIMER, "----------------------------------");
	}
	
	public static class Timer {
		public static final Timer DUMMY = new Timer("dummy") {
			@Override
			public void stop(){
				
			}
			@Override
			public void start(){
				
			}
		};
		
		static Timer startTimer(){
			return startTimer(null);
		}
		static Timer startTimer(String ctx){
			return startTimer(ctx,false);
		}
		static Timer startTimer(String ctx,boolean additive){
			if (!cat.isLoggable(ExtendedLevel.TIMER)){
				return DUMMY;
			}
			String context = (ctx == null ? getCaller().toString() : ctx );
			Map timerStatistics = getTimerStatistics();
			
			TimerStatistics ts = timerStatistics.get(context);
			if (ts == null){
				ts = new TimerStatistics(context);
				timerStatistics.put(context, ts);
			}
			Timer timer = new Timer(context,additive);
			timer.start();
			return timer;
		}

		private static StackTraceElement getCaller(){
			StackTraceElement[] elements = Thread.currentThread().getStackTrace();
			for (StackTraceElement element: elements){
				if (!element.getClassName().startsWith("com.venky.core.log") && !element.getClassName().startsWith("java")){
					return element;
				}
			}
			throw new RuntimeException("Timer class cannot be timed!");
		}
		
		
		private final String key; 
		private final boolean additive;
		public Timer(String key){
			this(key,false);
		}
		public Timer(String key,boolean additive){
			this.key = key;
			this.additive = additive;
		}
		
		private Long start = null;
		protected void start(){
			Stack timerStack = getTimerStack();
			if (!timerStack.isEmpty()){
				Timer previous = timerStack.peek();
				if (!previous.additive){
					previous.suspend();
				}
			}
			timerStack.push(this);
			resume();
		}
		protected void resume(){
			start = System.currentTimeMillis();
		}
		
		public void stop(){
			TimerStatistics statistics = suspend();
			statistics.callCount.increment();
			Stack timerStack = getTimerStack();
			Timer last  = null;

			//Pop timer stack till this.
			//List removed = new ArrayList();
			while(last != this && !timerStack.isEmpty()){
				if (last != null){
					cat.warning("Timer " + last.key + " not stopped!");
				}
				last = timerStack.pop();
			}

			if (!timerStack.isEmpty()){
				Timer previous = timerStack.peek();
				if (!previous.additive){
					previous.resume();
				}
			}
		}
		private TimerStatistics suspend(){
			long now = System.currentTimeMillis();
			TimerStatistics statistics = getTimerStatistics().get(key);
			if (start != null){
				statistics.elapsedTime.increment(now - start);
				start = null;
			}
			return statistics;
		}

	}
}