sysperfana/perfinvestigator/com.nokia.carbide.cpp.pi.graphicsmemory/src/com/nokia/carbide/cpp/pi/graphicsmemory/GraphicsMemoryTraceParser.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sysperfana/perfinvestigator/com.nokia.carbide.cpp.pi.graphicsmemory/src/com/nokia/carbide/cpp/pi/graphicsmemory/GraphicsMemoryTraceParser.java Wed Jun 23 15:05:09 2010 +0300
@@ -0,0 +1,292 @@
+/*
+ * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+ * All rights reserved.
+ * This component and the accompanying materials are made available
+ * under the terms of the License "Eclipse Public License v1.0"
+ * which accompanies this distribution, and is available
+ * at the URL "http://www.eclipse.org/legal/epl-v10.html".
+ *
+ * Initial Contributors:
+ * Nokia Corporation - initial contribution.
+ *
+ * Contributors:
+ *
+ * Description:
+ *
+ */
+
+package com.nokia.carbide.cpp.pi.graphicsmemory;
+
+import java.io.ByteArrayInputStream;
+import java.io.DataInputStream;
+import java.io.EOFException;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.nokia.carbide.cpp.internal.pi.model.GenericSampledTrace;
+import com.nokia.carbide.cpp.internal.pi.model.ParsedTraceData;
+import com.nokia.carbide.cpp.internal.pi.model.Parser;
+import com.nokia.carbide.cpp.pi.util.GeneralMessages;
+
+public class GraphicsMemoryTraceParser extends Parser {
+ private boolean debug = false;
+ private String version;
+
+ private GraphicsMemoryTrace memTrace;
+ private int readCount = 0;
+
+ // constants
+ public final static int SAMPLE_TOTAL_MEMORY_PROCESS_ID = -1;
+ public final static String SAMPLE_TOTAL_MEMORY_PROCESS_NAME = "TOTAL_MEMORY_USAGE"; //$NON-NLS-1$
+
+ public ParsedTraceData parse(File file) throws IOException {
+ if (!file.exists() || file.isDirectory()) {
+ throw new IOException(Messages
+ .getString("GraphicsMemoryTraceParser.cannotOpenTraceFile")); //$NON-NLS-1$
+ }
+ if (debug)
+ System.out
+ .println(Messages
+ .getString("GraphicsMemoryTraceParser.traceFileLength") + file.length()); //$NON-NLS-1$
+
+ parseMemTrace(file);
+ int versionNumber = convertVersionStringToInt(version);
+ memTrace.setVersion(versionNumber);
+
+ ParsedTraceData ptd = new ParsedTraceData();
+ ptd.traceData = this.getTrace();
+
+ return ptd;
+ }
+
+ private void parseV100GPUFile(DataInputStream dis) throws IOException {
+ // read the version again
+ byte[] version = readElementWithLength(dis);
+ if (debug)
+ System.out
+ .println(Messages
+ .getString("GraphicsMemoryTraceParser.readVersionDebug") + new String(version)); //$NON-NLS-1$
+ this.version = new String(version);
+
+ this.readV100GPUSample(dis);
+ }
+
+ public String getProfilerVersion() {
+ return version;
+ }
+
+ private void readV100GPUSample(DataInputStream dis) throws IOException {
+ memTrace = new GraphicsMemoryTrace();
+
+ GraphicsMemoryProcess process;
+
+ // read sample header length
+ dis.readUnsignedByte();
+ readCount++;
+
+ int length;
+ int mode = -1;
+ String processName = null;
+ GraphicsMemorySample gpuSample = null;
+ int usedMemory = -1;
+ int totalMemory = -1;
+ long sample = -1;
+
+ List<GraphicsMemoryProcess> processList = new ArrayList<GraphicsMemoryProcess>();
+ try {
+
+ while (true) {
+ length = dis.readUnsignedByte();
+ readCount++;
+ if (length == 1) {
+ mode = dis.readUnsignedByte();
+ readCount++;
+ } else {
+ throw new IOException(Messages
+ .getString("GraphicsMemoryTraceParser.wrongLength")); //$NON-NLS-1$
+ }
+
+ if (mode == 0xac) { // time stamp
+ // first there should be 4 bytes of sample time
+ sample = this.readTUint(dis);
+ }
+
+ else if (mode == 0xaa) { // process name
+ length = dis.readUnsignedByte();
+ readCount++; // process sample length
+ // reading process name
+ processName = readProcessName(dis, length);
+ } else if (mode == 0xab) { // process id
+ // reading process id
+ long processId = readTUint(dis);
+ // create process and sample
+ process = new GraphicsMemoryProcess(Integer
+ .valueOf((int) processId), processName);
+ gpuSample = new GraphicsMemorySample(process, (int) sample);
+
+ } else if (mode == 0xdb) { // total GPU data
+ // read the total GPU data
+ long total = readTUint(dis);
+ totalMemory = (int) total;
+
+ } else if (mode == 0xdc) { // used GPU data
+ // read the used GPU data
+ long used = readTUint(dis);
+ usedMemory = (int) used;
+
+ if (debug)
+ System.out
+ .println(MessageFormat
+ .format(
+ Messages
+ .getString("GraphicsMemoryTraceParser.readMemoryUsageDebug"), usedMemory, totalMemory, sample)); //$NON-NLS-1$
+ GraphicsMemorySample memoryUsageSample = new GraphicsMemorySample(
+ usedMemory, totalMemory, (int) sample);
+ memTrace.addSample(memoryUsageSample);
+ processList.add(memoryUsageSample.process);
+
+ length = dis.readUnsignedByte(); // read process sample
+ // length
+ readCount++;
+
+ } else if (mode == 0xde) { // private data
+ // read the private data
+ long privateSize = readTUint(dis);
+ gpuSample.privateSize = (int) privateSize;
+ } else if (mode == 0xdf) { // shared data
+ // read the shared data
+ long sharedSize = readTUint(dis);
+ gpuSample.sharedSize = (int) sharedSize;
+
+ if (debug)
+ System.out
+ .println(MessageFormat
+ .format(
+ Messages
+ .getString("GraphicsMemoryTraceParser.readProcessDebug"), gpuSample.process.processName, gpuSample.sampleSynchTime, Long.toHexString(gpuSample.process.processId), gpuSample.privateSize, gpuSample.sharedSize)); //$NON-NLS-1$
+
+ memTrace.addSample(gpuSample);
+ processList.add(gpuSample.process);
+
+ length = dis.readUnsignedByte(); // read process sample
+ // length
+ readCount++;
+ } else {
+ throw new IOException(
+ Messages
+ .getString("GraphicsMemoryTraceParser.wrongMode") + mode); //$NON-NLS-1$
+ }
+ }
+ } catch (EOFException e) {
+ memTrace.setProcesses(processList
+ .toArray(new GraphicsMemoryProcess[processList.size()]));
+ System.out.println(Messages
+ .getString("GraphicsMemoryTraceParser.finishedReading")); //$NON-NLS-1$
+ }
+ }
+
+ /*
+ * A method for calculating hash value for a string
+ */
+ public static long sum(String arg) {
+ int total = 0;
+ for (int i = 0; i < arg.length(); i++) {
+ total += (long) arg.charAt(i);
+ }
+ return total; // returns the sum of the chars after cast
+ }
+
+ private String readProcessName(DataInputStream dis, int length)
+ throws IOException {
+ if (length != 0) {
+ byte[] element = new byte[length];
+ dis.read(element, 0, length);
+ readCount += length;
+ return new String(element);
+ } else
+ return null;
+ }
+
+ private byte[] readElementWithLength(DataInputStream dis) throws IOException {
+ byte length = dis.readByte();
+ readCount++;
+ if (length != 0) {
+ byte[] element = new byte[length];
+ dis.read(element, 0, length);
+ readCount += length;
+ return element;
+ } else
+ return null;
+ }
+
+ private long readTUint(DataInputStream dis) throws IOException {
+ long result = dis.readUnsignedByte();
+ readCount++;
+ result += dis.readUnsignedByte() << 8;
+ readCount++;
+ result += dis.readUnsignedByte() << 16;
+ readCount++;
+ result += dis.readUnsignedByte() << 24;
+ readCount++;
+ return result;
+ }
+
+ private void parseMemTrace(File file) throws IOException {
+ DataInputStream dis = new DataInputStream(new FileInputStream(file));
+ byte[] traceArray = new byte[(int) file.length()];
+ dis.readFully(traceArray);
+
+ // test the graph mem trace version
+ String s = new String(traceArray, 1, traceArray[0]);
+ if (traceArray.length > 257) {
+ if (s.startsWith("Bappea_GPU_V1.00")) { //$NON-NLS-1$
+ ByteArrayInputStream bais = new ByteArrayInputStream(traceArray);
+ dis = new DataInputStream(bais);
+ this.parseV100GPUFile(dis);
+ return;
+ }
+ }
+ String version = s.substring(8, 12);
+ String traceType = s.substring(13, s.length());
+ System.out
+ .println(Messages
+ .getString("GraphicsMemoryTraceParser.foundVersion1") + version + Messages.getString("GraphicsMemoryTraceParser.foundVersion2") + traceType + Messages.getString("GraphicsMemoryTraceParser.foundVersion3")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ GeneralMessages
+ .showErrorMessage(Messages
+ .getString("GraphicsMemoryTraceParser.wrongTraceType1") + traceType + Messages.getString("GraphicsMemoryTraceParser.wrongTraceType2")); //$NON-NLS-1$ //$NON-NLS-2$
+ throw new IOException(
+ Messages.getString("GraphicsMemoryTraceParser.wrongTraceType1") + traceType + Messages.getString("GraphicsMemoryTraceParser.wrongTraceType2")); //$NON-NLS-1$ //$NON-NLS-2$
+
+ }
+
+ private GenericSampledTrace getTrace() {
+ return (GenericSampledTrace) memTrace;
+ }
+
+ private int convertVersionStringToInt(String version) {
+ // Coverts version number from string to int
+ int i = 0;
+ int versionInt = 0;
+ String versionString = ""; //$NON-NLS-1$
+
+ // goes string thru and copies all digits into another string
+ while (i < version.length()) {
+ if (Character.isDigit(version.charAt(i))) {
+ versionString += version.charAt(i);
+ }
+ i++;
+
+ }
+ // convert string to int
+ try {
+ versionInt = Integer.parseInt(versionString);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ return versionInt;
+ }
+}