/*
* 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;
}
}