Merge pull request #19969 from tajila/jfr3

JFR Writer fixes part1

Author: gacholio

runtime/vm/JFRChunkWriter.cpp

@@ -64,12 +64,11 @@ VM_JFRChunkWriter::writeJFRHeader()
 	/* pad */
 	_bufferWriter->writeU16(0); // 65
 
-	/* flags */
+	U_8 flags = JFR_HEADER_SPECIALFLAGS_COMPRESSED_INTS;
 	if (_finalWrite) {
-		_bufferWriter->writeU8(0x2); // 67 // final chunk bit?
-	} else {
-		_bufferWriter->writeU8(2);
+		flags |= JFR_HEADER_SPECIALFLAGS_LAST_CHUNK;
 	}
+	_bufferWriter->writeU8(flags);
 }
 
 U_8 *
@@ -597,7 +596,7 @@ VM_JFRChunkWriter::writeStacktraceCheckpointEvent()
 
 			/* number of stack frames */
 			UDATA framesCount = entry->numOfFrames;
-			_bufferWriter->writeU8(framesCount);
+			_bufferWriter->writeLEB128(framesCount);
 
 			for (UDATA i = 0; i < framesCount; i++) {
 				StackFrame *frame = entry->frames + i;

runtime/vm/JFRChunkWriter.hpp

@@ -35,6 +35,11 @@
 #include "ObjectAccessBarrierAPI.hpp"
 #include "VMHelpers.hpp"
 
+static constexpr const char * const intermediateChunkFileName = "openj9ChunkFile";
+
+static constexpr const int JFR_HEADER_SPECIALFLAGS_COMPRESSED_INTS = 1;
+static constexpr const int JFR_HEADER_SPECIALFLAGS_LAST_CHUNK = 2;
+
 static constexpr const char * const threadStateNames[] = {
 	"STATE_NEW",
 	"STATE_TERMINATED",
@@ -200,6 +205,34 @@ class VM_JFRChunkWriter {
 		return _buildResult;
 	}
 
+	void
+	writeIntermediateJFRChunkToFile()
+	{
+		UDATA written = 0;
+		char fileName[sizeof(intermediateChunkFileName) + 16 + sizeof(".jfr")];
+		sprintf(fileName, "%s%lX.jfr", intermediateChunkFileName, _vm->jfrState.jfrChunkCount);
+		UDATA len = _bufferWriter->getSize();
+		IDATA fd = j9file_open(fileName, EsOpenWrite | EsOpenCreate | EsOpenTruncate , 0666);
+
+		if (-1 == fd) {
+			_buildResult = FileIOError;
+			goto done;
+		}
+
+		written = j9file_write(fd, _bufferWriter->getBufferStart(), len);
+
+		if (len != written) {
+			_buildResult = FileIOError;
+		}
+
+		if (-1 != fd) {
+			j9file_close(fd);
+		}
+done:
+		return;
+
+	}
+
 	void writeJFRChunk()
 	{
 		U_8 *buffer = NULL;
@@ -269,6 +302,8 @@ class VM_JFRChunkWriter {
 
 			_bufferWriter = NULL;
 			j9mem_free_memory(buffer);
+
+			_vm->jfrState.jfrChunkCount += 1;
 		}
 done:
 		return;
@@ -403,6 +438,10 @@ class VM_JFRChunkWriter {
 			_buildResult = FileIOError;
 		}
 
+		if (_debug) {
+			writeIntermediateJFRChunkToFile();
+		}
+
 		return;
 	}
 

runtime/vm/JFRConstantPoolTypes.cpp

@@ -1101,4 +1101,18 @@ VM_JFRConstantPoolTypes::freeUTF8Strings(void *entry, void *userData)
 	return FALSE;
 }
 
+UDATA
+VM_JFRConstantPoolTypes::freeStackStraceEntries(void *entry, void *userData)
+{
+	StackTraceEntry *tableEntry = (StackTraceEntry *) entry;
+	J9VMThread *currentThread = (J9VMThread *)userData;
+	PORT_ACCESS_FROM_VMC(currentThread);
+
+	j9mem_free_memory(tableEntry->frames);
+	tableEntry->frames = NULL;
+
+	return FALSE;
+}
+
+
 #endif /* defined(J9VM_OPT_JFR) */

runtime/vm/JFRConstantPoolTypes.hpp

@@ -37,9 +37,19 @@
 #include "VMHelpers.hpp"
 
 J9_DECLARE_CONSTANT_UTF8(nullString, "(nullString)");
+J9_DECLARE_CONSTANT_UTF8(unknownClass, "(defaultPackage)/(unknownClass)");
+J9_DECLARE_CONSTANT_UTF8(nativeMethod, "(nativeMethod)");
+J9_DECLARE_CONSTANT_UTF8(nativeMethodSignature, "()");
 J9_DECLARE_CONSTANT_UTF8(defaultPackage, "(defaultPackage)");
 J9_DECLARE_CONSTANT_UTF8(bootLoaderName, "boostrapClassLoader");
 
+enum JFRStringConstants {
+	DefaultString = 0,
+	UnknownClass = 1,
+	NativeMethod = 2,
+	NativeMethodSignature = 3,
+};
+
 enum FrameType {
 	Interpreted = 0,
 	JIT,
@@ -250,8 +260,14 @@ class VM_JFRConstantPoolTypes {
 	/* default values */
 	ThreadGroupEntry _defaultThreadGroup;
 	StringUTF8Entry _defaultStringUTF8Entry;
+	StringUTF8Entry _unknownClassStringUTF8Entry;
+	StringUTF8Entry _nativeMethodStringUTF8Entry;
+	StringUTF8Entry _nativeMethodSignatureStringUTF8Entry;
 	PackageEntry _defaultPackageEntry;
 	ModuleEntry _defaultModuleEntry;
+	ClassEntry _defaultClassEntry;
+	MethodEntry _defaultMethodEntry;
+	StackTraceEntry _defaultStackTraceEntry;
 
 	UDATA _requiredBufferSize;
 	U_32 _currentFrameCount;
@@ -336,6 +352,8 @@ class VM_JFRConstantPoolTypes {
 
 	static UDATA freeUTF8Strings(void *entry, void *userData);
 
+	static UDATA freeStackStraceEntries(void *entry, void *userData);
+
 	U_32 getMethodEntry(J9ROMMethod *romMethod, J9Class *ramClass);
 
 	U_32 getClassEntry(J9Class *clazz);
@@ -381,14 +399,29 @@ class VM_JFRConstantPoolTypes {
 		VM_JFRConstantPoolTypes *cp = (VM_JFRConstantPoolTypes*) userData;
 		StackFrame *frame = &cp->_currentStackFrameBuffer[cp->_currentFrameCount];
 
-		if ((UDATA)-1 != bytecodeOffset) {
-			cp->_currentFrameCount++;
+		cp->_currentFrameCount++;
 
+		if ((NULL == ramClass) || (NULL == romMethod)) {
+			/* unknown native method */
+			frame->methodIndex = 0;
+			frame->frameType = Native;
+		} else {
 			frame->methodIndex = cp->getMethodEntry(romMethod, ramClass);
-			frame->lineNumber = lineNumber;
-			frame->bytecodeIndex = bytecodeOffset;
 			frame->frameType = Interpreted; /* TODO need a way to know if its JIT'ed and inlined */
 		}
+
+		if ((UDATA)-1 == bytecodeOffset) {
+			frame->bytecodeIndex = 0;
+		} else {
+			frame->bytecodeIndex = bytecodeOffset;
+		}
+
+		if ((UDATA)-1 == lineNumber) {
+			frame->lineNumber = 0;
+		} else {
+			frame->lineNumber = lineNumber;
+		}
+
 		return J9_STACKWALK_KEEP_ITERATING;
 	}
 
@@ -401,6 +434,9 @@ class VM_JFRConstantPoolTypes {
 			goto done;
 		}
 		_globalStringTable[0] = &_defaultStringUTF8Entry;
+		_globalStringTable[1] = &_unknownClassStringUTF8Entry;
+		_globalStringTable[2] = &_nativeMethodStringUTF8Entry;
+		_globalStringTable[3] = &_nativeMethodSignatureStringUTF8Entry;
 		_globalStringTable[_stringUTF8Count] = &_defaultPackageEntry;
 
 		hashTableForEachDo(_stringUTF8Table, &mergeStringUTF8EntriesToGlobalTable, this);
@@ -607,7 +643,16 @@ class VM_JFRConstantPoolTypes {
 
 	U_32 consumeStackTrace(J9VMThread *walkThread, UDATA *walkStateCache, UDATA numberOfFrames) {
 		U_32 index = U_32_MAX;
-		_currentStackFrameBuffer = (StackFrame*) j9mem_allocate_memory(sizeof(StackFrame) * numberOfFrames, J9MEM_CATEGORY_CLASSES);
+		UDATA expandedStackTraceCount = 0;
+
+		if (0 == numberOfFrames) {
+			index = 0;
+			goto done;
+		}
+
+		expandedStackTraceCount = iterateStackTraceImpl(_currentThread, (j9object_t*)walkStateCache, NULL, NULL, FALSE, FALSE, numberOfFrames, FALSE);
+
+		_currentStackFrameBuffer = (StackFrame*) j9mem_allocate_memory(sizeof(StackFrame) * expandedStackTraceCount, J9MEM_CATEGORY_CLASSES);
 		_currentFrameCount = 0;
 		if (NULL == _currentStackFrameBuffer) {
 			_buildResult = OutOfMemory;
@@ -617,7 +662,8 @@ class VM_JFRConstantPoolTypes {
 		iterateStackTraceImpl(_currentThread, (j9object_t*)walkStateCache, &stackTraceCallback, this, FALSE, FALSE, numberOfFrames, FALSE);
 
 		index = addStackTraceEntry(walkThread, VM_JFRUtils::getCurrentTimeNanos(privatePortLibrary, _buildResult), _currentFrameCount);
-		_stackFrameCount += numberOfFrames;
+		_stackFrameCount += expandedStackTraceCount;
+		_currentStackFrameBuffer = NULL;
 
 done:
 		return index;
@@ -756,28 +802,59 @@ class VM_JFRConstantPoolTypes {
 		 * For package zero is the deafult package, for Module zero is the unnamed module. ThreadGroup
 		 * zero is NULL threadGroup.
 		 */
-		_stringUTF8Count++;
+		_stringUTF8Count += 1;
 		_defaultStringUTF8Entry = {0};
 		_defaultStringUTF8Entry.string = (J9UTF8*)&nullString;
 
-		_moduleCount++;
+		_stringUTF8Count += 1;
+		_unknownClassStringUTF8Entry = {0};
+		_unknownClassStringUTF8Entry.string = (J9UTF8*)&unknownClass;
+
+		_stringUTF8Count += 1;
+		_nativeMethodStringUTF8Entry = {0};
+		_nativeMethodStringUTF8Entry.string = (J9UTF8*)&nativeMethod;
+
+		_stringUTF8Count += 1;
+		_nativeMethodSignatureStringUTF8Entry = {0};
+		_nativeMethodSignatureStringUTF8Entry.string = (J9UTF8*)&nativeMethodSignature;
+
+		_moduleCount += 1;
 		_defaultModuleEntry = {0};
 		_firstModuleEntry = &_defaultModuleEntry;
 		_previousModuleEntry = _firstModuleEntry;
 
-		_packageCount++;
+		_packageCount += 1;
 		_defaultPackageEntry = {0};
 		_defaultPackageEntry.exported = TRUE;
 		_defaultPackageEntry.packageName = J9UTF8_DATA((J9UTF8*) &defaultPackage);
 		_defaultPackageEntry.packageNameLength = J9UTF8_LENGTH((J9UTF8*) &defaultPackage);
 		_firstPackageEntry = &_defaultPackageEntry;
 		_previousPackageEntry = _firstPackageEntry;
 
-		_threadGroupCount++;
+		_threadGroupCount += 1;
 		_defaultThreadGroup = {0};
 		_firstThreadGroupEntry = &_defaultThreadGroup;
 		_previousThreadGroupEntry = _firstThreadGroupEntry;
 
+		_classCount += 1;
+		_defaultClassEntry = {0};
+		_defaultClassEntry.nameStringUTF8Index = (U_32)UnknownClass;
+		_firstClassEntry = &_defaultClassEntry;
+		_previousClassEntry = _firstClassEntry;
+
+		_methodCount += 1;
+		_defaultMethodEntry = {0};
+		_defaultMethodEntry.nameStringUTF8Index = (U_32)NativeMethod;
+		_defaultMethodEntry.descriptorStringUTF8Index = (U_32)NativeMethodSignature;
+		/* default class */
+		_defaultMethodEntry.classIndex = 0;
+		_firstMethodEntry = &_defaultMethodEntry;
+		_previousMethodEntry = _firstMethodEntry;
+
+		_stackTraceCount += 1;
+		_defaultStackTraceEntry = {0};
+		_firstStackTraceEntry = &_defaultStackTraceEntry;
+		_previousStackTraceEntry = _firstStackTraceEntry;
 
 done:
 		return;
@@ -786,6 +863,7 @@ class VM_JFRConstantPoolTypes {
 	~VM_JFRConstantPoolTypes()
 	{
 		hashTableForEachDo(_stringUTF8Table, &freeUTF8Strings, _currentThread);
+		hashTableForEachDo(_stackTraceTable, &freeStackStraceEntries, _currentThread);
 		hashTableFree(_classTable);
 		hashTableFree(_packageTable);
 		hashTableFree(_moduleTable);