test/jvmti-common/BaseTraceParser.java - platform/art - Git at Google

 /*
  * Copyright (C) 2023 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.
  */

 import java.io.DataInputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
 import java.util.Set;

 abstract class BaseTraceParser {
     public static final int MAGIC_NUMBER = 0x574f4c53;
     public static final int DUAL_CLOCK_VERSION = 3;
     public static final int WALL_CLOCK_VERSION = 2;
     public static final int STREAMING_DUAL_CLOCK_VERSION = 0xF3;
     public static final int STREAMING_WALL_CLOCK_VERSION = 0xF2;
     public static final String START_SECTION_ID = "*";
     public static final String METHODS_SECTION_ID = "*methods";
     public static final String THREADS_SECTION_ID = "*threads";
     public static final String END_SECTION_ID = "*end";
     public static final Set<String> ignoredMethods = Set.of(
             "java.lang.ref.ReferenceQueue add (Ljava/lang/ref/Reference;)V ReferenceQueue.java");

     public void InitializeParser(File file) throws IOException {
         dataStream = new DataInputStream(new FileInputStream(file));
         methodIdMap = new HashMap<Integer, String>();
         threadIdMap = new HashMap<Integer, String>();
         nestingLevelMap = new HashMap<Integer, Integer>();
         ignoredMethodNestingLevelMap = new HashMap<Integer, Integer>();
         threadEventsMap = new HashMap<String, String>();
         threadTimestamp1Map = new HashMap<Integer, Integer>();
         threadTimestamp2Map = new HashMap<Integer, Integer>();
     }

     public void closeFile() throws IOException {
         dataStream.close();
     }

     public String readString(int numBytes) throws IOException {
         byte[] buffer = new byte[numBytes];
         dataStream.readFully(buffer);
         return new String(buffer, StandardCharsets.UTF_8);
     }

     public String readLine() throws IOException {
         StringBuilder sb = new StringBuilder();
         char lineSeparator = '\n';
         char c = (char) dataStream.readUnsignedByte();
         while (c != lineSeparator) {
             sb.append(c);
             c = (char) dataStream.readUnsignedByte();
         }
         return sb.toString();
     }

     public int readNumber(int numBytes) throws IOException {
         int number = 0;
         for (int i = 0; i < numBytes; i++) {
             number += dataStream.readUnsignedByte() << (i * 8);
         }
         return number;
     }

     public void validateTraceHeader(int expectedVersion) throws Exception {
         // Read 4-byte magicNumber.
         int magicNumber = readNumber(4);
         if (magicNumber != MAGIC_NUMBER) {
             throw new Exception("Magic number doesn't match. Expected "
                                 + Integer.toHexString(MAGIC_NUMBER) + " Got "
                                 + Integer.toHexString(magicNumber));
         }
         // Read 2-byte version.
         int version = readNumber(2);
         if (version != expectedVersion) {
             throw new Exception("Unexpected version. Expected " + expectedVersion + " Got "
                                 + version);
         }
         traceFormatVersion = version & 0xF;
         // Read 2-byte headerLength length.
         int headerLength = readNumber(2);
         // Read 8-byte starting time - Ignore timestamps since they are not deterministic.
         dataStream.skipBytes(8);
         // 4 byte magicNumber + 2 byte version + 2 byte offset + 8 byte timestamp.
         int numBytesRead = 16;
         if (version >= DUAL_CLOCK_VERSION) {
             // Read 2-byte record size.
             // TODO(mythria): Check why this is needed. We can derive recordSize from version. Not
             // sure why this is needed.
             recordSize = readNumber(2);
             numBytesRead += 2;
         }
         // Skip any padding.
         if (headerLength > numBytesRead) {
             dataStream.skipBytes(headerLength - numBytesRead);
         }
     }

     public int GetThreadID() throws IOException {
         // Read 2-byte thread-id. On host thread-ids can be greater than 16-bit but it is truncated
         // to 16-bits in the trace.
         int threadId = readNumber(2);
         return threadId;
     }

     public int GetEntryHeader() throws IOException {
         // Read 1-byte header type
         return readNumber(1);
     }

     public void ProcessMethodInfoEntry() throws IOException {
         // Read 2-byte method info size
         int headerLength = readNumber(2);
         // Read header size data.
         String methodInfo = readString(headerLength);
         String[] tokens = methodInfo.split("\t", 2);
         // Get methodId and record methodId -> methodName map.
         int methodId = Integer.decode(tokens[0]);
         String methodLine = tokens[1].replace('\t', ' ');
         methodLine = methodLine.substring(0, methodLine.length() - 1);
         methodIdMap.put(methodId, methodLine);
     }

     public void ProcessThreadInfoEntry() throws IOException {
         // Read 2-byte thread id
         int threadId = readNumber(2);
         // Read 2-byte thread info size
         int headerLength = readNumber(2);
         // Read header size data.
         String threadInfo = readString(headerLength);
         threadIdMap.put(threadId, threadInfo);
     }

     public boolean ShouldCheckThread(int threadId, String threadName) throws Exception {
         if (!threadIdMap.containsKey(threadId)) {
             System.out.println("no threadId -> name  mapping for thread " + threadId);
             // TODO(b/279547877): Ideally we should throw here, since it isn't expected. Just
             // continuing to get more logs from the bots to see what's happening here. The
             // test will fail anyway because the expected output will be different.
             return true;
         }

         return threadIdMap.get(threadId).equals(threadName);
     }

     public String eventTypeToString(int eventType, int threadId) {
         if (!nestingLevelMap.containsKey(threadId)) {
             nestingLevelMap.put(threadId, 0);
         }

         int nestingLevel = nestingLevelMap.get(threadId);
         String str = "";
         for (int i = 0; i < nestingLevel; i++) {
             str += ".";
         }
         switch (eventType) {
             case 0:
                 nestingLevel++;
                 str += ".>>";
                 break;
             case 1:
                 nestingLevel--;
                 str += "<<";
                 break;
             case 2:
                 nestingLevel--;
                 str += "<<E";
                 break;
             default:
                 str += "??";
         }
         nestingLevelMap.put(threadId, nestingLevel);
         return str;
     }

     public void CheckTimestamp(int timestamp, int threadId,
                                HashMap<Integer, Integer> threadTimestampMap) throws Exception {
         if (threadTimestampMap.containsKey(threadId)) {
             int oldTimestamp = threadTimestampMap.get(threadId);
             if (timestamp < oldTimestamp) {
                 throw new Exception("timestamps are not increasing current: " + timestamp
                                     + "  earlier: " + oldTimestamp);
             }
         }
         threadTimestampMap.put(threadId, timestamp);
     }

     public String ProcessEventEntry(int threadId, String methodNameFilter)
             throws IOException, Exception {
         // Read 4-byte method value
         int methodAndEvent = readNumber(4);
         int methodId = methodAndEvent & ~0x3;
         int eventType = methodAndEvent & 0x3;

         // Depending on the version skip either one or two timestamps.
         int timestamp1 = readNumber(4);
         CheckTimestamp(timestamp1, threadId, threadTimestamp1Map);
         if (traceFormatVersion != 2) {
             // Read second timestamp
             int timestamp2 = readNumber(4);
             CheckTimestamp(timestamp2, threadId, threadTimestamp2Map);
         }

         String methodName = methodIdMap.get(methodId);
         if ((methodNameFilter != null) && !methodName.contains(methodNameFilter)) {
             return null;
         }

         int currNestingLevel = 0;
         if (nestingLevelMap.containsKey(threadId)) {
             currNestingLevel = nestingLevelMap.get(threadId);
         }
         boolean recordMethodEvent = true;
         if (!ignoredMethodNestingLevelMap.containsKey(threadId)) {
             if (ignoredMethods.contains(methodName)) {
                 // This should be an entry event.
                 if (eventType != 0) {
                     throw new Exception("Seeing an exit for an ignored event without an entry");
                 }
                 ignoredMethodNestingLevelMap.put(threadId, currNestingLevel);
                 recordMethodEvent = false;
             }
         } else {
             // We need to ignore all calls until the ignored method exits.
             int ignoredMethodDepth = ignoredMethodNestingLevelMap.get(threadId);
             // If this is a method exit and we are at the right depth remove the entry so we start
             // recording from the next event.
             if (ignoredMethodDepth == currNestingLevel - 1 && eventType != 0) {
                 ignoredMethodNestingLevelMap.remove(threadId);
                 if (!ignoredMethods.contains(methodName)) {
                     throw new Exception(
                             "Unexpected method on exit. Mismatch on method entry and exit");
                 }
             }
             recordMethodEvent = false;
         }
         String str = eventTypeToString(eventType, threadId) + " " + threadIdMap.get(threadId) + " "
                 + methodName;
         return recordMethodEvent ? str : null;
     }

     public void UpdateThreadEvents(int threadId, String entry) {
         String threadName = threadIdMap.get(threadId);
         if (!threadEventsMap.containsKey(threadName)) {
             threadEventsMap.put(threadName, entry);
             return;
         }
         threadEventsMap.put(threadName, threadEventsMap.get(threadName) + "\n" + entry);
     }

     public abstract void CheckTraceFileFormat(File traceFile, int expectedVersion,
                                               String threadName, String methodNameFilter)
             throws Exception;

     DataInputStream dataStream;
     HashMap<Integer, String> methodIdMap;
     HashMap<Integer, String> threadIdMap;
     HashMap<Integer, Integer> nestingLevelMap;
     HashMap<Integer, Integer> ignoredMethodNestingLevelMap;
     HashMap<String, String> threadEventsMap;
     HashMap<Integer, Integer> threadTimestamp1Map;
     HashMap<Integer, Integer> threadTimestamp2Map;
     int recordSize = 0;
     int traceFormatVersion = 0;
 }
	/*
	* Copyright (C) 2023 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.
	*/

	import java.io.DataInputStream;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.IOException;
	import java.nio.charset.StandardCharsets;
	import java.util.HashMap;
	import java.util.Set;

	abstract class BaseTraceParser {
	public static final int MAGIC_NUMBER = 0x574f4c53;
	public static final int DUAL_CLOCK_VERSION = 3;
	public static final int WALL_CLOCK_VERSION = 2;
	public static final int STREAMING_DUAL_CLOCK_VERSION = 0xF3;
	public static final int STREAMING_WALL_CLOCK_VERSION = 0xF2;
	public static final String START_SECTION_ID = "*";
	public static final String METHODS_SECTION_ID = "*methods";
	public static final String THREADS_SECTION_ID = "*threads";
	public static final String END_SECTION_ID = "*end";
	public static final Set<String> ignoredMethods = Set.of(
	"java.lang.ref.ReferenceQueue add (Ljava/lang/ref/Reference;)V ReferenceQueue.java");

	public void InitializeParser(File file) throws IOException {
	dataStream = new DataInputStream(new FileInputStream(file));
	methodIdMap = new HashMap<Integer, String>();
	threadIdMap = new HashMap<Integer, String>();
	nestingLevelMap = new HashMap<Integer, Integer>();
	ignoredMethodNestingLevelMap = new HashMap<Integer, Integer>();
	threadEventsMap = new HashMap<String, String>();
	threadTimestamp1Map = new HashMap<Integer, Integer>();
	threadTimestamp2Map = new HashMap<Integer, Integer>();
	}

	public void closeFile() throws IOException {
	dataStream.close();
	}

	public String readString(int numBytes) throws IOException {
	byte[] buffer = new byte[numBytes];
	dataStream.readFully(buffer);
	return new String(buffer, StandardCharsets.UTF_8);
	}

	public String readLine() throws IOException {
	StringBuilder sb = new StringBuilder();
	char lineSeparator = '\n';
	char c = (char) dataStream.readUnsignedByte();
	while (c != lineSeparator) {
	sb.append(c);
	c = (char) dataStream.readUnsignedByte();
	}
	return sb.toString();
	}

	public int readNumber(int numBytes) throws IOException {
	int number = 0;
	for (int i = 0; i < numBytes; i++) {
	number += dataStream.readUnsignedByte() << (i * 8);
	}
	return number;
	}

	public void validateTraceHeader(int expectedVersion) throws Exception {
	// Read 4-byte magicNumber.
	int magicNumber = readNumber(4);
	if (magicNumber != MAGIC_NUMBER) {
	throw new Exception("Magic number doesn't match. Expected "
	+ Integer.toHexString(MAGIC_NUMBER) + " Got "
	+ Integer.toHexString(magicNumber));
	}
	// Read 2-byte version.
	int version = readNumber(2);
	if (version != expectedVersion) {
	throw new Exception("Unexpected version. Expected " + expectedVersion + " Got "
	+ version);
	}
	traceFormatVersion = version & 0xF;
	// Read 2-byte headerLength length.
	int headerLength = readNumber(2);
	// Read 8-byte starting time - Ignore timestamps since they are not deterministic.
	dataStream.skipBytes(8);
	// 4 byte magicNumber + 2 byte version + 2 byte offset + 8 byte timestamp.
	int numBytesRead = 16;
	if (version >= DUAL_CLOCK_VERSION) {
	// Read 2-byte record size.
	// TODO(mythria): Check why this is needed. We can derive recordSize from version. Not
	// sure why this is needed.
	recordSize = readNumber(2);
	numBytesRead += 2;
	}
	// Skip any padding.
	if (headerLength > numBytesRead) {
	dataStream.skipBytes(headerLength - numBytesRead);
	}
	}

	public int GetThreadID() throws IOException {
	// Read 2-byte thread-id. On host thread-ids can be greater than 16-bit but it is truncated
	// to 16-bits in the trace.
	int threadId = readNumber(2);
	return threadId;
	}

	public int GetEntryHeader() throws IOException {
	// Read 1-byte header type
	return readNumber(1);
	}

	public void ProcessMethodInfoEntry() throws IOException {
	// Read 2-byte method info size
	int headerLength = readNumber(2);
	// Read header size data.
	String methodInfo = readString(headerLength);
	String[] tokens = methodInfo.split("\t", 2);
	// Get methodId and record methodId -> methodName map.
	int methodId = Integer.decode(tokens[0]);
	String methodLine = tokens[1].replace('\t', ' ');
	methodLine = methodLine.substring(0, methodLine.length() - 1);
	methodIdMap.put(methodId, methodLine);
	}

	public void ProcessThreadInfoEntry() throws IOException {
	// Read 2-byte thread id
	int threadId = readNumber(2);
	// Read 2-byte thread info size
	int headerLength = readNumber(2);
	// Read header size data.
	String threadInfo = readString(headerLength);
	threadIdMap.put(threadId, threadInfo);
	}

	public boolean ShouldCheckThread(int threadId, String threadName) throws Exception {
	if (!threadIdMap.containsKey(threadId)) {
	System.out.println("no threadId -> name mapping for thread " + threadId);
	// TODO(b/279547877): Ideally we should throw here, since it isn't expected. Just
	// continuing to get more logs from the bots to see what's happening here. The
	// test will fail anyway because the expected output will be different.
	return true;
	}

	return threadIdMap.get(threadId).equals(threadName);
	}

	public String eventTypeToString(int eventType, int threadId) {
	if (!nestingLevelMap.containsKey(threadId)) {
	nestingLevelMap.put(threadId, 0);
	}

	int nestingLevel = nestingLevelMap.get(threadId);
	String str = "";
	for (int i = 0; i < nestingLevel; i++) {
	str += ".";
	}
	switch (eventType) {
	case 0:
	nestingLevel++;
	str += ".>>";
	break;
	case 1:
	nestingLevel--;
	str += "<<";
	break;
	case 2:
	nestingLevel--;
	str += "<<E";
	break;
	default:
	str += "??";
	}
	nestingLevelMap.put(threadId, nestingLevel);
	return str;
	}

	public void CheckTimestamp(int timestamp, int threadId,
	HashMap<Integer, Integer> threadTimestampMap) throws Exception {
	if (threadTimestampMap.containsKey(threadId)) {
	int oldTimestamp = threadTimestampMap.get(threadId);
	if (timestamp < oldTimestamp) {
	throw new Exception("timestamps are not increasing current: " + timestamp
	+ " earlier: " + oldTimestamp);
	}
	}
	threadTimestampMap.put(threadId, timestamp);
	}

	public String ProcessEventEntry(int threadId, String methodNameFilter)
	throws IOException, Exception {
	// Read 4-byte method value
	int methodAndEvent = readNumber(4);
	int methodId = methodAndEvent & ~0x3;
	int eventType = methodAndEvent & 0x3;

	// Depending on the version skip either one or two timestamps.
	int timestamp1 = readNumber(4);
	CheckTimestamp(timestamp1, threadId, threadTimestamp1Map);
	if (traceFormatVersion != 2) {
	// Read second timestamp
	int timestamp2 = readNumber(4);
	CheckTimestamp(timestamp2, threadId, threadTimestamp2Map);
	}

	String methodName = methodIdMap.get(methodId);
	if ((methodNameFilter != null) && !methodName.contains(methodNameFilter)) {
	return null;
	}

	int currNestingLevel = 0;
	if (nestingLevelMap.containsKey(threadId)) {
	currNestingLevel = nestingLevelMap.get(threadId);
	}
	boolean recordMethodEvent = true;
	if (!ignoredMethodNestingLevelMap.containsKey(threadId)) {
	if (ignoredMethods.contains(methodName)) {
	// This should be an entry event.
	if (eventType != 0) {
	throw new Exception("Seeing an exit for an ignored event without an entry");
	}
	ignoredMethodNestingLevelMap.put(threadId, currNestingLevel);
	recordMethodEvent = false;
	}
	} else {
	// We need to ignore all calls until the ignored method exits.
	int ignoredMethodDepth = ignoredMethodNestingLevelMap.get(threadId);
	// If this is a method exit and we are at the right depth remove the entry so we start
	// recording from the next event.
	if (ignoredMethodDepth == currNestingLevel - 1 && eventType != 0) {
	ignoredMethodNestingLevelMap.remove(threadId);
	if (!ignoredMethods.contains(methodName)) {
	throw new Exception(
	"Unexpected method on exit. Mismatch on method entry and exit");
	}
	}
	recordMethodEvent = false;
	}
	String str = eventTypeToString(eventType, threadId) + " " + threadIdMap.get(threadId) + " "
	+ methodName;
	return recordMethodEvent ? str : null;
	}

	public void UpdateThreadEvents(int threadId, String entry) {
	String threadName = threadIdMap.get(threadId);
	if (!threadEventsMap.containsKey(threadName)) {
	threadEventsMap.put(threadName, entry);
	return;
	}
	threadEventsMap.put(threadName, threadEventsMap.get(threadName) + "\n" + entry);
	}

	public abstract void CheckTraceFileFormat(File traceFile, int expectedVersion,
	String threadName, String methodNameFilter)
	throws Exception;

	DataInputStream dataStream;
	HashMap<Integer, String> methodIdMap;
	HashMap<Integer, String> threadIdMap;
	HashMap<Integer, Integer> nestingLevelMap;
	HashMap<Integer, Integer> ignoredMethodNestingLevelMap;
	HashMap<String, String> threadEventsMap;
	HashMap<Integer, Integer> threadTimestamp1Map;
	HashMap<Integer, Integer> threadTimestamp2Map;
	int recordSize = 0;
	int traceFormatVersion = 0;
	}