Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   [The "BSD license"]
   Copyright (c) 2005-2009 Terence Parr
   All rights reserved.
  
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
   1. Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
  2. Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
  3. The name of the author may not be used to endorse or promote products
      derived from this software without specific prior written permission.
 
  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 package org.antlr.runtime.debug;
 
 
 import java.util.*;

Using the debug event interface, track what is happening in the parser and record statistics about the runtime.
 
 public class Profiler extends BlankDebugEventListener {
 	public static final String DATA_SEP = "\t";
 	public static final String newline = System.getProperty("line.separator");
 
 	static boolean dump = false;
 
 	private static final String TAG = "ANTLR:DEBUG:Profiler";
 
 	public static class ProfileStats {
 		public String Version;
 		public String name;
 		public int numRuleInvocations;
 		public int numUniqueRulesInvoked;
 		public int numDecisionEvents;
 		public int numDecisionsCovered;
 		public int maxRuleInvocationDepth;
 		public float avgkPerDecisionEvent;
 		public int numBacktrackOccurrences// doesn't count gated DFA edges
 
 		public int numFixedDecisions;
 		public int numCyclicDecisions;
 //		int Stats.min(toArray(decisionMaxSynPredLookaheads);
 //		int Stats.max(toArray(decisionMaxSynPredLookaheads);
 //		int Stats.avg(toArray(decisionMaxSynPredLookaheads);
 //		int Stats.stddev(toArray(decisionMaxSynPredLookaheads);
 		public int numSemanticPredicates;
 		public int numTokens;
 		public int numHiddenTokens;
 		public int numCharsMatched;
 		public int numHiddenCharsMatched;
 		public int numReportedErrors;
 		public int numMemoizationCacheHits;
 	}
 
 	public static class DecisionDescriptor {
 		public int decision;
 		public String fileName;
 		public String ruleName;
 		public int line;
 		public int pos;
 		public boolean couldBacktrack;
 
 		public int n;
 		public float avgk// avg across all decision events
 		public int maxk;
 		public int numBacktrackOccurrences;
 		public int numSemPredEvals;
	}
	// all about a specific exec of a single decision
	public static class DecisionEvent {
		public int startIndex;
		public int k;
		public boolean backtracks// doesn't count gated DFA edges
		public boolean evalSemPred;
		public long startTime;
		public long stopTime;
	}

Because I may change the stats, I need to track that for later computations to be consistent.
	public static final String Version = "3";
	public static final String RUNTIME_STATS_FILENAME = "runtime.stats";

Ack, should not store parser; can't do remote stuff. Well, we pass input stream around too so I guess it's ok.
	public DebugParser parser = null;
	// working variables
	protected int ruleLevel = 0;
	//protected int decisionLevel = 0;
	protected Set<StringuniqueRules = new HashSet<String>();
	protected Stack<StringcurrentGrammarFileName = new Stack();
	protected Stack<StringcurrentRuleName = new Stack();
	protected Stack<IntegercurrentLine = new Stack();
	protected Stack<IntegercurrentPos = new Stack();
	// Vector<DecisionStats>
	//protected Vector decisions = new Vector(200); // need setSize
	// Record a DecisionData for each decision we hit while parsing
	protected int backtrackDepth;
	public Profiler() {
	}
	public Profiler(DebugParser parser) {
		this. = parser;
	}
	public void enterRule(String grammarFileNameString ruleName) {
//		System.out.println("enterRule "+grammarFileName+":"+ruleName);
		.add(grammarFileName+":"+ruleName);
		.pushgrammarFileName );
		.pushruleName );
	}
	public void exitRule(String grammarFileNameString ruleName) {
	}

Track memoization; this is not part of standard debug interface but is triggered by profiling. Code gen inserts an override for this method in the recognizer, which triggers this method. Called from alreadyParsedRule().
	public void examineRuleMemoization(IntStream input,
									   int ruleIndex,
									   int stopIndex// index or MEMO_RULE_UNKNOWN...
									   String ruleName)
	{
		if (..println("examine memo "+ruleName+" at "+input.index()+": "+stopIndex);
		if ( stopIndex==. ) {
			//System.out.println("rule "+ruleIndex+" missed @ "+input.index());
			.++; // we'll have to enter
		}
		else {
			// regardless of rule success/failure, if in cache, we have a cache hit
			//System.out.println("rule "+ruleIndex+" hit @ "+input.index());
		}
	}

Warning: doesn't track success/failure, just unique recording event
	public void memoize(IntStream input,
						int ruleIndex,
						int ruleStartIndex,
						String ruleName)
	{
		// count how many entries go into table
		if () { //System.out.println("memoize "+ruleName);
			android.util.Log.i("memoize "+ruleName);
		}
	}
	public void location(int lineint pos) {
	}
	public void enterDecision(int decisionNumberboolean couldBacktrack) {
		int startingLookaheadIndex = .getTokenStream().index();
		if (  ) { //System.out.println("enterDecision canBacktrack="+couldBacktrack+" "+ decisionNumber +
						   //" backtrack depth " + backtrackDepth +
						   //" @ " + input.get(input.index()) +
						   //" rule " +locationDescription());
				android.util.Log.i("enterDecision canBacktrack="+couldBacktrack+" "decisionNumber +
							" backtrack depth " +  +
							" @ " + input.get(input.index()) +
							" rule " +locationDescription());
		}
		DecisionDescriptor descriptor = .get(gdecisionNumber);
		if ( descriptor == null ) {
			descriptor = new DecisionDescriptor();
			.put(gdecisionNumberdescriptor);
			descriptor.decision = decisionNumber;
			descriptor.fileName = (String).peek();
			descriptor.ruleName = (String).peek();
			descriptor.line = (Integer).peek();
			descriptor.pos = (Integer).peek();
			descriptor.couldBacktrack = couldBacktrack;
		}
		descriptor.n++;
		d.decision = descriptor;
		d.startTime = System.currentTimeMillis();
		d.startIndex = startingLookaheadIndex;
	}
	public void exitDecision(int decisionNumber) {
		d.stopTime = System.currentTimeMillis();
		int numHidden = getNumberOfHiddenTokens(d.startIndexlastTokenIndex);
		int depth = lastTokenIndex - d.startIndex - numHidden + 1; // +1 counts consuming start token as 1
		d.k = depth;
		d.decision.maxk = Math.max(d.decision.maxkdepth);
		if () { //System.out.println("exitDecision "+decisionNumber+" in "+d.decision.ruleName+
						   //" lookahead "+d.k +" max token "+lastRealTokenTouchedInDecision);
				android.util.Log.i("exitDecision "+decisionNumber+" in "+d.decision.ruleName+
							" lookahead "+d.k +" max token "+);
		}
		.add(d); // done with decision; track all
	}
	public void consumeToken(Token token) {
		if () { //System.out.println("consume token "+token);
				android.util.Log.i("consume token "+token);
		}
		if ( !inDecision() ) {
			return;
		}
		{
		}
		// compute lookahead depth
		int thisRefIndex = token.getTokenIndex();
		int numHidden = getNumberOfHiddenTokens(d.startIndexthisRefIndex);
		int depth = thisRefIndex - d.startIndex - numHidden + 1; // +1 counts consuming start token as 1
		//d.maxk = Math.max(d.maxk, depth);
		if () { //System.out.println("consume "+thisRefIndex+" "+depth+" tokens ahead in "+
						   //d.decision.ruleName+"-"+d.decision.decision+" start index "+d.startIndex);		
			android.util.Log.i("consume "+thisRefIndex+" "+depth+" tokens ahead in "+
						d.decision.ruleName+"-"+d.decision.decision+" start index "+d.startIndex);
		}
	}

The parser is in a decision if the decision depth > 0. This works for backtracking also, which can have nested decisions.
	public boolean inDecision() {
		return .size()>0;
	}
	public void consumeHiddenToken(Token token) {
		//System.out.println("consume hidden token "+token);
	}

Track refs to lookahead if in a fixed/nonfixed decision.
	public void LT(int iToken t) {
		if ( inDecision() && i>0 ) {
			if () { //System.out.println("LT("+i+")="+t+" index "+t.getTokenIndex()+" relative to "+d.decision.ruleName+"-"+
							   //d.decision.decision+" start index "+d.startIndex);
					android.util.Log.i("LT("+i+")="+t+" index "+t.getTokenIndex()+" relative to "+d.decision.ruleName+"-"+	
								d.decision.decision+" start index "+d.startIndex);
			}
			{
				if () { //System.out.println("set last token "+lastRealTokenTouchedInDecision);
					android.util.Log.i("set last token "+);
				}
			}
			// get starting index off stack
//			int stackTop = lookaheadStack.size()-1;
//			Integer startingIndex = (Integer)lookaheadStack.get(stackTop);
//			// compute lookahead depth
//			int thisRefIndex = parser.getTokenStream().index();
//			int numHidden =
//				getNumberOfHiddenTokens(startingIndex.intValue(), thisRefIndex);
//			int depth = i + thisRefIndex - startingIndex.intValue() - numHidden;
//			/*
//			System.out.println("LT("+i+") @ index "+thisRefIndex+" is depth "+depth+
//				" max is "+maxLookaheadInCurrentDecision);
//			*/
//			if ( depth>maxLookaheadInCurrentDecision ) {
//				maxLookaheadInCurrentDecision = depth;
//			}
//			d.maxk = currentDecision()/
		}
	}

Track backtracking decisions. You'll see a fixed or cyclic decision and then a backtrack. enter rule ... enter decision LA and possibly consumes (for cyclic DFAs) begin backtrack level mark m rewind m end backtrack level, success exit decision ... exit rule
	public void beginBacktrack(int level) {
		if () { //System.out.println("enter backtrack "+level);
			android.util.Log.i("enter backtrack "+level);
		}
		if ( e.decision.couldBacktrack ) {
			e.decision.numBacktrackOccurrences++;
			e.backtracks = true;
		}
	}

Successful or not, track how much lookahead synpreds use
	public void endBacktrack(int levelboolean successful) {
		if () { //System.out.println("exit backtrack "+level+": "+successful);
			android.util.Log.i("exit backtrack "+level+": "+successful);
		}
	}
	public void mark(int i) {
		if () { //System.out.println("mark "+i);
			android.util.Log.i("mark "+i);
		}
	}
	public void rewind(int i) {
		if () { //System.out.println("rewind "+i);
			android.util.Log.i("rewind "+i);
		}
	}
	public void rewind() {
		if () { //System.out.println("rewind");
			android.util.Log.i("rewind");
		}
	}
	}
	}
	public void semanticPredicate(boolean resultString predicate) {
		if ( inDecision() ) {
			d.evalSemPred = true;
			d.decision.numSemPredEvals++;
			if () { //System.out.println("eval "+predicate+" in "+d.decision.ruleName+"-"+
							   //d.decision.decision);
				android.util.Log.i("eval "+predicate+" in "+d.decision.ruleName+"-"+
							d.decision.decision);
			}
		}
	}
	public void terminate() {
			//System.out.println("decision "+e.decision.decision+": k="+e.k);
			e.decision.avgk += e.k;
			if ( e.backtracks ) { // doesn't count gated syn preds on DFA edges
			}
		}
			d.avgk /= (double)d.n;
			if ( d.couldBacktrack ) {
				float percentBacktracks = d.numBacktrackOccurrences / (float)d.n;
				//System.out.println("dec "+d.decision+" backtracks "+percentBacktracks*100+"%");
			}
			// ignore rules that backtrack along gated DFA edges
			if ( d.numBacktrackOccurrences > 0 ) {
			}
		}
		. *= 100; // it's a percentage
		//System.err.println(toString());
		android.util.Log.e(toString());
		//System.err.println(getDecisionStatsDump());
		android.util.Log.e(getDecisionStatsDump());
//		String stats = toNotifyString();
//		try {
//			Stats.writeReport(RUNTIME_STATS_FILENAME,stats);
//		}
//		catch (IOException ioe) {
//			System.err.println(ioe);
//			ioe.printStackTrace(System.err);
//		}
	}
	public void setParser(DebugParser parser) {
		this. = parser;
	}
	// R E P O R T I N G
	public String toNotifyString() {
		StringBuffer buf = new StringBuffer();
		buf.append('\t');
//		buf.append('\t');
//		buf.append(numRuleInvocations);
//		buf.append('\t');
//		buf.append(maxRuleInvocationDepth);
//		buf.append('\t');
//		buf.append(numFixedDecisions);
//		buf.append('\t');
//		buf.append(Stats.min(decisionMaxFixedLookaheads));
//		buf.append('\t');
//		buf.append(Stats.max(decisionMaxFixedLookaheads));
//		buf.append('\t');
//		buf.append(Stats.avg(decisionMaxFixedLookaheads));
//		buf.append('\t');
//		buf.append(Stats.stddev(decisionMaxFixedLookaheads));
//		buf.append('\t');
//		buf.append(numCyclicDecisions);
//		buf.append('\t');
//		buf.append(Stats.min(decisionMaxCyclicLookaheads));
//		buf.append('\t');
//		buf.append(Stats.max(decisionMaxCyclicLookaheads));
//		buf.append('\t');
//		buf.append(Stats.avg(decisionMaxCyclicLookaheads));
//		buf.append('\t');
//		buf.append(Stats.stddev(decisionMaxCyclicLookaheads));
//		buf.append('\t');
//		buf.append(numBacktrackDecisions);
//		buf.append('\t');
//		buf.append(Stats.min(toArray(decisionMaxSynPredLookaheads)));
//		buf.append('\t');
//		buf.append(Stats.max(toArray(decisionMaxSynPredLookaheads)));
//		buf.append('\t');
//		buf.append(Stats.avg(toArray(decisionMaxSynPredLookaheads)));
//		buf.append('\t');
//		buf.append(Stats.stddev(toArray(decisionMaxSynPredLookaheads)));
//		buf.append('\t');
//		buf.append(numSemanticPredicates);
//		buf.append('\t');
//		buf.append(parser.getTokenStream().size());
//		buf.append('\t');
//		buf.append(numHiddenTokens);
//		buf.append('\t');
//		buf.append(numCharsMatched);
//		buf.append('\t');
//		buf.append(numHiddenCharsMatched);
//		buf.append('\t');
//		buf.append(numberReportedErrors);
//		buf.append('\t');
//		buf.append(numMemoizationCacheHits);
//		buf.append('\t');
//		buf.append(numMemoizationCacheMisses);
//		buf.append('\t');
//		buf.append(numGuessingRuleInvocations);
//		buf.append('\t');
//		buf.append(numMemoizationCacheEntries);
		return buf.toString();
	}
	public String toString() {
		return toString(getReport());
	}
	public ProfileStats getReport() {
//		TokenStream input = parser.getTokenStream();
//		for (int i=0; i<input.size()&& lastRealTokenTouchedInDecision !=null&&i<= lastRealTokenTouchedInDecision.getTokenIndex(); i++) {
//			Token t = input.get(i);
//			if ( t.getChannel()!=Token.DEFAULT_CHANNEL ) {
//				stats.numHiddenTokens++;
//				stats.numHiddenCharsMatched += t.getText().length();
//			}
//		}
		//stats.numCharsMatched = lastTokenConsumed.getStopIndex() + 1;
		return ;
	}
		return ;
	}
	public List getDecisionEvents() {
	}
	public static String toString(ProfileStats stats) {
		StringBuffer buf = new StringBuffer();
		buf.append("ANTLR Runtime Report; Profile Version ");
		buf.append(stats.Version);
		buf.append("parser name ");
		buf.append(stats.name);
		buf.append("Number of rule invocations ");
		buf.append(stats.numRuleInvocations);
		buf.append("Number of unique rules visited ");
		buf.append(stats.numUniqueRulesInvoked);
		buf.append("Number of decision events ");
		buf.append(stats.numDecisionEvents);
		buf.append("Overall average k per decision event ");
		buf.append(stats.avgkPerDecisionEvent);
		buf.append("Number of backtracking occurrences (can be multiple per decision) ");
		buf.append(stats.numBacktrackOccurrences);
		buf.append("Overall average k per decision event that backtracks ");
		buf.append(stats.avgkPerBacktrackingDecisionEvent);
		buf.append("Number of rule invocations while backtracking ");
		buf.append(stats.numGuessingRuleInvocations);
		buf.append("num decisions that potentially backtrack ");
		buf.append(stats.numDecisionsThatPotentiallyBacktrack);
		buf.append("num decisions that do backtrack ");
		buf.append(stats.numDecisionsThatDoBacktrack);
		buf.append("num decisions that potentially backtrack but don't ");
		buf.append(stats.numDecisionsThatPotentiallyBacktrack - stats.numDecisionsThatDoBacktrack);
		buf.append("average % of time a potentially backtracking decision backtracks ");
		buf.append(stats.averageDecisionPercentBacktracks);
		buf.append("num unique decisions covered ");
		buf.append(stats.numDecisionsCovered);
		buf.append("max rule invocation nesting depth ");
		buf.append(stats.maxRuleInvocationDepth);
//		buf.append("number of fixed lookahead decisions ");
//		buf.append();
//		buf.append('\n');
//		buf.append("min lookahead used in a fixed lookahead decision ");
//		buf.append();
//		buf.append('\n');
//		buf.append("max lookahead used in a fixed lookahead decision ");
//		buf.append();
//		buf.append('\n');
//		buf.append("average lookahead depth used in fixed lookahead decisions ");
//		buf.append();
//		buf.append('\n');
//		buf.append("standard deviation of depth used in fixed lookahead decisions ");
//		buf.append();
//		buf.append('\n');
//		buf.append("number of arbitrary lookahead decisions ");
//		buf.append();
//		buf.append('\n');
//		buf.append("min lookahead used in an arbitrary lookahead decision ");
//		buf.append();
//		buf.append('\n');
//		buf.append("max lookahead used in an arbitrary lookahead decision ");
//		buf.append();
//		buf.append('\n');
//		buf.append("average lookahead depth used in arbitrary lookahead decisions ");
//		buf.append();
//		buf.append('\n');
//		buf.append("standard deviation of depth used in arbitrary lookahead decisions ");
//		buf.append();
//		buf.append('\n');
//		buf.append("number of evaluated syntactic predicates ");
//		buf.append();
//		buf.append('\n');
//		buf.append("min lookahead used in a syntactic predicate ");
//		buf.append();
//		buf.append('\n');
//		buf.append("max lookahead used in a syntactic predicate ");
//		buf.append();
//		buf.append('\n');
//		buf.append("average lookahead depth used in syntactic predicates ");
//		buf.append();
//		buf.append('\n');
//		buf.append("standard deviation of depth used in syntactic predicates ");
//		buf.append();
//		buf.append('\n');
		buf.append("rule memoization cache size ");
		buf.append(stats.numMemoizationCacheEntries);
		buf.append("number of rule memoization cache hits ");
		buf.append(stats.numMemoizationCacheHits);
		buf.append("number of rule memoization cache misses ");
		buf.append(stats.numMemoizationCacheMisses);
//		buf.append("number of evaluated semantic predicates ");
//		buf.append();
//		buf.append(newline);
		buf.append("number of tokens ");
		buf.append(stats.numTokens);
		buf.append("number of hidden tokens ");
		buf.append(stats.numHiddenTokens);
		buf.append("number of char ");
		buf.append(stats.numCharsMatched);
		buf.append("number of hidden char ");
		buf.append(stats.numHiddenCharsMatched);
		buf.append("number of syntax errors ");
		buf.append(stats.numReportedErrors);
		return buf.toString();
	}
		StringBuffer buf = new StringBuffer();
		buf.append("location");
		buf.append("n");
		buf.append("avgk");
		buf.append("maxk");
		buf.append("synpred");
		buf.append("sempred");
		buf.append("canbacktrack");
		buf.append("\n");
		for (String fileName : .keySet()) {
			for (int d : .keySet(fileName)) {
				DecisionDescriptor s = .get(fileNamed);
				buf.append(s.decision);
				buf.append("@");
				buf.append(locationDescription(s.fileName,s.ruleName,s.line,s.pos)); // decision number
				buf.append(s.n);
				buf.append(String.format("%.2f",s.avgk));
				buf.append(s.maxk);
				buf.append(s.numBacktrackOccurrences);
				buf.append(s.numSemPredEvals);
				buf.append(s.couldBacktrack ?"1":"0");
			}
		}
		return buf.toString();
	}
	protected int[] trim(int[] Xint n) {
		if ( n<X.length ) {
			int[] trimmed = new int[n];
			System.arraycopy(X,0,trimmed,0,n);
			X = trimmed;
		}
		return X;
	}
	protected int[] toArray(List a) {
		int[] x = new int[a.size()];
		for (int i = 0; i < a.size(); i++) {
			Integer I = (Integera.get(i);
			x[i] = I.intValue();
		}
		return x;
	}

Get num hidden tokens between i..j inclusive
	public int getNumberOfHiddenTokens(int iint j) {
		int n = 0;
		for (int ti = iti<input.size() && ti <= jti++) {
			Token t = input.get(ti);
				n++;
			}
		}
		return n;
	}
	protected String locationDescription() {
	}
	protected String locationDescription(String fileString ruleint lineint pos) {
		return file+":"+line+":"+pos+"(" + rule + ")";
	}
New to GrepCode? Check out our FAQ X