eclipse/plugins/com.android.ide.eclipse.gldebugger/src/com/android/ide/eclipse/gltrace/TraceFileParserTask.java - platform/sdk - Git at Google

 /*
  * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.ide.eclipse.gltrace;

 import com.android.ide.eclipse.gltrace.GLProtoBuf.GLMessage;
 import com.android.ide.eclipse.gltrace.GLProtoBuf.GLMessage.Function;
 import com.android.ide.eclipse.gltrace.format.GLAPISpec;
 import com.android.ide.eclipse.gltrace.format.GLMessageFormatter;
 import com.android.ide.eclipse.gltrace.model.GLCall;
 import com.android.ide.eclipse.gltrace.model.GLFrame;
 import com.android.ide.eclipse.gltrace.model.GLTrace;
 import com.android.ide.eclipse.gltrace.state.transforms.StateTransformFactory;

 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.jface.operation.IRunnableWithProgress;

 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.RandomAccessFile;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Set;
 import java.util.TreeSet;

 public class TraceFileParserTask implements IRunnableWithProgress {
     private static final TraceFileReader sReader = new TraceFileReader();

     private static final GLMessageFormatter sGLMessageFormatter =
             new GLMessageFormatter(GLAPISpec.getSpecs());

     private String mTraceFilePath;
     private RandomAccessFile mFile;

     private List<GLCall> mGLCalls;
     private Set<Integer> mGLContextIds;

     private GLTrace mTrace;

     /**
      * Construct a GL Trace file parser.
      * @param path path to trace file
      */
     public TraceFileParserTask(String path) {
         try {
             mFile = new RandomAccessFile(path, "r"); //$NON-NLS-1$
         } catch (FileNotFoundException e) {
             throw new IllegalArgumentException(e);
         }

         mTraceFilePath = path;
         mGLCalls = new ArrayList<GLCall>();
         mGLContextIds = new TreeSet<Integer>();
     }

     private void addMessage(int index, long traceFileOffset, GLMessage msg, long startTime) {
         String formattedMsg;
         try {
             formattedMsg = sGLMessageFormatter.formatGLMessage(msg);
         } catch (Exception e) {
             formattedMsg = String.format("%s()", msg.getFunction().toString()); //$NON-NLS-1$
         }

         GLCall c = new GLCall(index,
                                 startTime,
                                 traceFileOffset,
                                 formattedMsg,
                                 msg.getFunction(),
                                 msg.hasFb(),
                                 msg.getContextId(),
                                 msg.getDuration(),
                                 msg.getThreadtime());

         addProperties(c, msg);

         try {
             c.setStateTransformations(StateTransformFactory.getTransformsFor(msg));
         } catch (Exception e) {
             c.setStateTransformationCreationError(e.getMessage());
             GlTracePlugin.getDefault().logMessage("Error while creating transformations for "
                                                         + c.toString() + ":");
             GlTracePlugin.getDefault().logMessage(e.getMessage());
         }

         mGLCalls.add(c);
         mGLContextIds.add(Integer.valueOf(c.getContextId()));
     }

     /** Save important values from the {@link GLMessage} in the {@link GLCall} as properties. */
     private void addProperties(GLCall c, GLMessage msg) {
         switch (msg.getFunction()) {
         case glPushGroupMarkerEXT:
             // void PushGroupMarkerEXT(sizei length, const char *marker);
             // save the marker name
             c.addProperty(GLCall.PROPERTY_MARKERNAME,
                     msg.getArgs(1).getCharValue(0).toStringUtf8());
             break;
         case glVertexAttribPointerData:
             // void glVertexAttribPointerData(GLuint indx, GLint size, GLenum type,
             //         GLboolean normalized, GLsizei stride, const GLvoid* ptr,
             //         int minIndex, int maxIndex)
             c.addProperty(GLCall.PROPERTY_VERTEX_ATTRIB_POINTER_SIZE,
                     Integer.valueOf(msg.getArgs(1).getIntValue(0)));
             c.addProperty(GLCall.PROPERTY_VERTEX_ATTRIB_POINTER_TYPE,
                     GLEnum.valueOf(msg.getArgs(2).getIntValue(0)));
             c.addProperty(GLCall.PROPERTY_VERTEX_ATTRIB_POINTER_DATA,
                     msg.getArgs(5).getRawBytes(0).toByteArray());
             break;
         default:
             break;
         }
     }

     /**
      * Parse the entire file and create a {@link GLTrace} object that can be retrieved
      * using {@link #getTrace()}.
      */
     @Override
     public void run(IProgressMonitor monitor) throws InvocationTargetException,
             InterruptedException {
         long fileLength;
         try {
             fileLength = mFile.length();
         } catch (IOException e1) {
             fileLength = 0;
         }

         monitor.beginTask("Parsing OpenGL Trace File",
                 fileLength > 0 ? 100 : IProgressMonitor.UNKNOWN);

         List<GLFrame> glFrames = null;

         try {
             GLMessage msg = null;
             int msgCount = 0;
             long filePointer = mFile.getFilePointer();
             int percentParsed = 0;

             // counters that maintain some statistics about the trace messages
             long minTraceStartTime = Long.MAX_VALUE;

             while ((msg = sReader.getMessageAtOffset(mFile, -1)) != null) {
                 if (minTraceStartTime > msg.getStartTime()) {
                     minTraceStartTime = msg.getStartTime();
                 }

                 addMessage(msgCount, filePointer, msg, msg.getStartTime() - minTraceStartTime);

                 filePointer = mFile.getFilePointer();
                 msgCount++;

                 if (monitor.isCanceled()) {
                     throw new InterruptedException();
                 }

                 if (fileLength > 0) {
                     int percentParsedNow = (int)((filePointer * 100) / fileLength);
                     monitor.worked(percentParsedNow - percentParsed);
                     percentParsed = percentParsedNow;
                 }
             }

             if (mGLContextIds.size() > 1) {
                 // if there are multiple contexts, then the calls may arrive at the
                 // host out of order. So we perform a sort based on the invocation time.
                 Collections.sort(mGLCalls, new Comparator<GLCall>() {
                     @Override
                     public int compare(GLCall c1, GLCall c2) {
                         long diff = (c1.getStartTime() - c2.getStartTime());

                         // We could return diff casted to an int. But in Java, casting
                         // from a long to an int truncates the bits and will not preserve
                         // the sign. So we resort to comparing the diff to 0 and returning
                         // the sign.
                         if (diff == 0) {
                             return 0;
                         } else if (diff > 0) {
                             return 1;
                         } else {
                             return -1;
                         }
                     }
                 });

                 // reassign indices after sorting
                 for (int i = 0; i < mGLCalls.size(); i++) {
                     mGLCalls.get(i).setIndex(i);
                 }
             }

             glFrames = createFrames(mGLCalls);
         } catch (Exception e) {
             throw new InvocationTargetException(e);
         } finally {
             try {
                 mFile.close();
             } catch (IOException e) {
                 // ignore exception while closing file
             }
             monitor.done();
         }

         File f = new File(mTraceFilePath);
         TraceFileInfo fileInfo = new TraceFileInfo(mTraceFilePath, f.length(), f.lastModified());
         mTrace = new GLTrace(fileInfo, glFrames, mGLCalls, new ArrayList<Integer>(mGLContextIds));
     }

     /** Assign GL calls to GL Frames. */
     private List<GLFrame> createFrames(List<GLCall> calls) {
         List<GLFrame> glFrames = new ArrayList<GLFrame>();
         int startCallIndex = 0;
         int frameIndex = 0;

         for (int i = 0; i < calls.size(); i++) {
             GLCall c = calls.get(i);
             if (c.getFunction() == Function.eglSwapBuffers) {
                 glFrames.add(new GLFrame(frameIndex, startCallIndex, i + 1));
                 startCallIndex = i + 1;
                 frameIndex++;
             }
         }

         // assign left over calls at the end to the last frame
         if (startCallIndex != mGLCalls.size()) {
             glFrames.add(new GLFrame(frameIndex, startCallIndex, mGLCalls.size()));
         }

         return glFrames;
     }

     /**
      * Retrieve the trace object constructed from messages in the trace file.
      */
     public GLTrace getTrace() {
         return mTrace;
     }
 }
	/*
	* Copyright (C) 2011 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.ide.eclipse.gltrace;

	import com.android.ide.eclipse.gltrace.GLProtoBuf.GLMessage;
	import com.android.ide.eclipse.gltrace.GLProtoBuf.GLMessage.Function;
	import com.android.ide.eclipse.gltrace.format.GLAPISpec;
	import com.android.ide.eclipse.gltrace.format.GLMessageFormatter;
	import com.android.ide.eclipse.gltrace.model.GLCall;
	import com.android.ide.eclipse.gltrace.model.GLFrame;
	import com.android.ide.eclipse.gltrace.model.GLTrace;
	import com.android.ide.eclipse.gltrace.state.transforms.StateTransformFactory;

	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.jface.operation.IRunnableWithProgress;

	import java.io.File;
	import java.io.FileNotFoundException;
	import java.io.IOException;
	import java.io.RandomAccessFile;
	import java.lang.reflect.InvocationTargetException;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.List;
	import java.util.Set;
	import java.util.TreeSet;

	public class TraceFileParserTask implements IRunnableWithProgress {
	private static final TraceFileReader sReader = new TraceFileReader();

	private static final GLMessageFormatter sGLMessageFormatter =
	new GLMessageFormatter(GLAPISpec.getSpecs());

	private String mTraceFilePath;
	private RandomAccessFile mFile;

	private List<GLCall> mGLCalls;
	private Set<Integer> mGLContextIds;

	private GLTrace mTrace;

	/**
	* Construct a GL Trace file parser.
	* @param path path to trace file
	*/
	public TraceFileParserTask(String path) {
	try {
	mFile = new RandomAccessFile(path, "r"); //$NON-NLS-1$
	} catch (FileNotFoundException e) {
	throw new IllegalArgumentException(e);
	}

	mTraceFilePath = path;
	mGLCalls = new ArrayList<GLCall>();
	mGLContextIds = new TreeSet<Integer>();
	}

	private void addMessage(int index, long traceFileOffset, GLMessage msg, long startTime) {
	String formattedMsg;
	try {
	formattedMsg = sGLMessageFormatter.formatGLMessage(msg);
	} catch (Exception e) {
	formattedMsg = String.format("%s()", msg.getFunction().toString()); //$NON-NLS-1$
	}

	GLCall c = new GLCall(index,
	startTime,
	traceFileOffset,
	formattedMsg,
	msg.getFunction(),
	msg.hasFb(),
	msg.getContextId(),
	msg.getDuration(),
	msg.getThreadtime());

	addProperties(c, msg);

	try {
	c.setStateTransformations(StateTransformFactory.getTransformsFor(msg));
	} catch (Exception e) {
	c.setStateTransformationCreationError(e.getMessage());
	GlTracePlugin.getDefault().logMessage("Error while creating transformations for "
	+ c.toString() + ":");
	GlTracePlugin.getDefault().logMessage(e.getMessage());
	}

	mGLCalls.add(c);
	mGLContextIds.add(Integer.valueOf(c.getContextId()));
	}

	/** Save important values from the {@link GLMessage} in the {@link GLCall} as properties. */
	private void addProperties(GLCall c, GLMessage msg) {
	switch (msg.getFunction()) {
	case glPushGroupMarkerEXT:
	// void PushGroupMarkerEXT(sizei length, const char *marker);
	// save the marker name
	c.addProperty(GLCall.PROPERTY_MARKERNAME,
	msg.getArgs(1).getCharValue(0).toStringUtf8());
	break;
	case glVertexAttribPointerData:
	// void glVertexAttribPointerData(GLuint indx, GLint size, GLenum type,
	// GLboolean normalized, GLsizei stride, const GLvoid* ptr,
	// int minIndex, int maxIndex)
	c.addProperty(GLCall.PROPERTY_VERTEX_ATTRIB_POINTER_SIZE,
	Integer.valueOf(msg.getArgs(1).getIntValue(0)));
	c.addProperty(GLCall.PROPERTY_VERTEX_ATTRIB_POINTER_TYPE,
	GLEnum.valueOf(msg.getArgs(2).getIntValue(0)));
	c.addProperty(GLCall.PROPERTY_VERTEX_ATTRIB_POINTER_DATA,
	msg.getArgs(5).getRawBytes(0).toByteArray());
	break;
	default:
	break;
	}
	}

	/**
	* Parse the entire file and create a {@link GLTrace} object that can be retrieved
	* using {@link #getTrace()}.
	*/
	@Override
	public void run(IProgressMonitor monitor) throws InvocationTargetException,
	InterruptedException {
	long fileLength;
	try {
	fileLength = mFile.length();
	} catch (IOException e1) {
	fileLength = 0;
	}

	monitor.beginTask("Parsing OpenGL Trace File",
	fileLength > 0 ? 100 : IProgressMonitor.UNKNOWN);

	List<GLFrame> glFrames = null;

	try {
	GLMessage msg = null;
	int msgCount = 0;
	long filePointer = mFile.getFilePointer();
	int percentParsed = 0;

	// counters that maintain some statistics about the trace messages
	long minTraceStartTime = Long.MAX_VALUE;

	while ((msg = sReader.getMessageAtOffset(mFile, -1)) != null) {
	if (minTraceStartTime > msg.getStartTime()) {
	minTraceStartTime = msg.getStartTime();
	}

	addMessage(msgCount, filePointer, msg, msg.getStartTime() - minTraceStartTime);

	filePointer = mFile.getFilePointer();
	msgCount++;

	if (monitor.isCanceled()) {
	throw new InterruptedException();
	}

	if (fileLength > 0) {
	int percentParsedNow = (int)((filePointer * 100) / fileLength);
	monitor.worked(percentParsedNow - percentParsed);
	percentParsed = percentParsedNow;
	}
	}

	if (mGLContextIds.size() > 1) {
	// if there are multiple contexts, then the calls may arrive at the
	// host out of order. So we perform a sort based on the invocation time.
	Collections.sort(mGLCalls, new Comparator<GLCall>() {
	@Override
	public int compare(GLCall c1, GLCall c2) {
	long diff = (c1.getStartTime() - c2.getStartTime());

	// We could return diff casted to an int. But in Java, casting
	// from a long to an int truncates the bits and will not preserve
	// the sign. So we resort to comparing the diff to 0 and returning
	// the sign.
	if (diff == 0) {
	return 0;
	} else if (diff > 0) {
	return 1;
	} else {
	return -1;
	}
	}
	});

	// reassign indices after sorting
	for (int i = 0; i < mGLCalls.size(); i++) {
	mGLCalls.get(i).setIndex(i);
	}
	}

	glFrames = createFrames(mGLCalls);
	} catch (Exception e) {
	throw new InvocationTargetException(e);
	} finally {
	try {
	mFile.close();
	} catch (IOException e) {
	// ignore exception while closing file
	}
	monitor.done();
	}

	File f = new File(mTraceFilePath);
	TraceFileInfo fileInfo = new TraceFileInfo(mTraceFilePath, f.length(), f.lastModified());
	mTrace = new GLTrace(fileInfo, glFrames, mGLCalls, new ArrayList<Integer>(mGLContextIds));
	}

	/** Assign GL calls to GL Frames. */
	private List<GLFrame> createFrames(List<GLCall> calls) {
	List<GLFrame> glFrames = new ArrayList<GLFrame>();
	int startCallIndex = 0;
	int frameIndex = 0;

	for (int i = 0; i < calls.size(); i++) {
	GLCall c = calls.get(i);
	if (c.getFunction() == Function.eglSwapBuffers) {
	glFrames.add(new GLFrame(frameIndex, startCallIndex, i + 1));
	startCallIndex = i + 1;
	frameIndex++;
	}
	}

	// assign left over calls at the end to the last frame
	if (startCallIndex != mGLCalls.size()) {
	glFrames.add(new GLFrame(frameIndex, startCallIndex, mGLCalls.size()));
	}

	return glFrames;
	}

	/**
	* Retrieve the trace object constructed from messages in the trace file.
	*/
	public GLTrace getTrace() {
	return mTrace;
	}
	}