--- /dev/null 2016-10-25 08:46:44.038854975 +0200
+++ new/src/share/classes/sun/evtracing/processing/TraceEventPrintHandler.java 2016-10-25 10:40:46.259802073 +0200
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) 2014, 2015, Dynatrace and/or its affiliates. All rights reserved.
+ *
+ * This file is part of the Lock Contention Tracing Subsystem for the HotSpot
+ * Virtual Machine, which is developed at Christian Doppler Laboratory on
+ * Monitoring and Evolution of Very-Large-Scale Software Systems. Please
+ * contact us at if you need additional information
+ * or have any questions.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work. If not, see .
+ *
+ */
+package sun.evtracing.processing;
+
+import static java.lang.System.err;
+import sun.evtracing.parser.ClassLoaderUnloadEvent;
+import sun.evtracing.parser.ClassMetadataEvent;
+import sun.evtracing.parser.GroupEvent;
+import sun.evtracing.parser.MetadataResetEvent;
+import sun.evtracing.parser.MethodMetadataEvent;
+import sun.evtracing.parser.MonitorContendedEnterEvent;
+import sun.evtracing.parser.MonitorContendedEnteredEvent;
+import sun.evtracing.parser.MonitorContendedExitedEvent;
+import sun.evtracing.parser.MonitorDeflateEvent;
+import sun.evtracing.parser.MonitorInflateEvent;
+import sun.evtracing.parser.SafepointBeginEvent;
+import sun.evtracing.parser.SafepointEndEvent;
+import sun.evtracing.parser.StackMetadataEvent;
+import sun.evtracing.parser.ThreadExitEvent;
+import sun.evtracing.parser.ThreadInterruptEvent;
+import sun.evtracing.parser.ThreadNameChangeEvent;
+import sun.evtracing.parser.ThreadParkBeginEvent;
+import sun.evtracing.parser.ThreadParkEndEvent;
+import sun.evtracing.parser.ThreadStartEvent;
+import sun.evtracing.parser.ThreadStateChangeEvent;
+import sun.evtracing.parser.ThreadUnparkEvent;
+import sun.evtracing.parser.VMEndEvent;
+
+public class TraceEventPrintHandler extends DelegateTraceEventHandler {
+
+ private long time = -1;
+
+ public TraceEventPrintHandler(TraceEventHandler delegate) {
+ super(delegate);
+ }
+
+ private String update(long time) {
+ long diff = time - this.time;
+ if (this.time == -1) {
+ diff = 0;
+ }
+ this.time = time;
+ return String.format("time +%05d", diff / 100);
+ }
+
+ @Override
+ public void threadStart(ThreadStartEvent event) {
+ err.printf("thread %d %s start: \"%s\"%n", event.thread().identifier(), update(event.timestamp()), event.name());
+ super.threadStart(event);
+ }
+
+ @Override
+ public void threadNameChange(ThreadNameChangeEvent event) {
+ err.printf("thread %d %s name change of thread %d: \"%s\"%n", event.thread().identifier(), update(event.timestamp()), event.affectedThread().identifier(), event.newName());
+ super.threadNameChange(event);
+ }
+
+ @Override
+ public void threadStateChange(ThreadStateChangeEvent event) {
+ err.printf("thread %d %s state change of thread %d: %s%n", event.thread().identifier(), update(event.timestamp()), event.affectedThread().identifier(), event.newState().toString());
+ super.threadStateChange(event);
+ }
+
+ @Override
+ public void threadInterrupt(ThreadInterruptEvent event) {
+ err.printf("thread %d %s interrupt of thread %d%n", event.thread().identifier(), update(event.timestamp()), event.affectedThread().identifier());
+ super.threadInterrupt(event);
+ }
+
+ @Override
+ public void threadExit(ThreadExitEvent event) {
+ err.printf("thread %d %s end%n", event.thread().identifier(), update(event.timestamp()));
+ super.threadExit(event);
+ }
+
+ @Override
+ public void threadParkBegin(ThreadParkBeginEvent event) {
+ err.printf("thread %d %s seq %05d park begin nestingLevel %d isAbsolute %b for %d%n", event.thread().identifier(), update(event.timestamp()), event.sequenceNumber(), event.nestingLevel(), event.isAbsolute(), event.parkTime());
+ super.threadParkBegin(event);
+ }
+
+ @Override
+ public void threadParkEnd(ThreadParkEndEvent event) {
+ err.printf("thread %d %s seq %05d park end %s caused by unpark %d%n", event.thread().identifier(), update(event.timestamp()), event.sequenceNumber(), event.parkReturnCode(), event.unparkSequenceNumber());
+ super.threadParkEnd(event);
+ }
+
+ @Override
+ public void threadUnpark(ThreadUnparkEvent event) {
+ err.printf("thread %d %s seq %05d unpark thread %d replaced unpark %d%n", event.thread().identifier(), update(event.timestamp()), event.sequenceNumber(), event.unparkedThread().identifier(), event.chainedSequenceNumber());
+ super.threadUnpark(event);
+ }
+
+ @Override
+ public void monitorInflate(MonitorInflateEvent event) {
+ err.printf("thread %d %s inflated monitor %d%n", event.thread().identifier(), update(event.timestamp()), event.monitor());
+ super.monitorInflate(event);
+ }
+
+ @Override
+ public void monitorDeflate(MonitorDeflateEvent event) {
+ err.printf("thread %d %s deflated monitor %d%n", event.thread().identifier(), update(event.timestamp()), event.monitor());
+ super.monitorDeflate(event);
+ }
+
+ @Override
+ public void monitorContendedEnter(MonitorContendedEnterEvent event) {
+ err.printf("thread %d %s contended enter on %d with stack trace %d%n", event.thread().identifier(), update(event.timestamp()), event.monitor(), event.stack().identifier());
+ super.monitorContendedEnter(event);
+ }
+
+ @Override
+ public void monitorContendedEntered(MonitorContendedEnteredEvent event) {
+ err.printf("thread %d %s contended entered on %d%n", event.thread().identifier(), update(event.timestamp()), event.monitor());
+ super.monitorContendedEntered(event);
+ }
+
+ @Override
+ public void monitorContendedExited(MonitorContendedExitedEvent event) {
+ err.printf("thread %d %s contended exited on %d with stack trace %d%n", event.thread().identifier(), update(event.timestamp()), event.monitor(), event.stack().identifier());
+ super.monitorContendedExited(event);
+ }
+
+ @Override
+ public void classMetadata(ClassMetadataEvent event) {
+ err.printf("class %d from class loader %d has name %s%n", event.clazz(), event.classLoader(), event.name());
+ super.classMetadata(event);
+ }
+
+ @Override
+ public void safepointBegin(SafepointBeginEvent event) {
+ err.printf("thread %d %s begin safepoint %s%n", event.thread().identifier(), update(event.timestamp()), event.reason().toString());
+ super.safepointBegin(event);
+ }
+
+ @Override
+ public void safepointEnd(SafepointEndEvent event) {
+ err.printf("thread %d %s end safepoint, %d op(s) processed%n", event.thread().identifier(), update(event.timestamp()), event.processedOps());
+ super.safepointEnd(event);
+ }
+
+ @Override
+ public void endVM(VMEndEvent event) {
+ err.printf("thread %d %s end VM%n", event.thread().identifier(), update(event.timestamp()));
+ super.endVM(event);
+ }
+
+ @Override
+ public void methodMetadata(MethodMetadataEvent event) {
+ err.printf("method %d from class %d has name %s and signature %s%n", event.method(), event.clazz().identifier(), event.name(), event.signature());
+ super.methodMetadata(event);
+ }
+
+ @Override
+ public void classLoaderUnload(ClassLoaderUnloadEvent event) {
+ err.printf("class loader %d unloaded%n", event.classLoader());
+ super.classLoaderUnload(event);
+ }
+
+ @Override
+ public void stackMetadata(StackMetadataEvent event) {
+ err.printf("stack trace %d with %d frames%n", event.stack(), event.methods().length);
+ super.stackMetadata(event);
+ }
+
+ @Override
+ public void metadataReset(MetadataResetEvent event) {
+ err.printf("thread %d metadata reset%n", event.thread().identifier());
+ super.metadataReset(event);
+ }
+
+ @Override
+ public void group(GroupEvent event) {
+ err.printf("thread %d group %d %d src %s@%s%n", event.thread().identifier(), event.sequenceBeginReference(), event.sequenceNumber(), event.clazz().metadata().name(), Integer.toHexString(event.obj()));
+ super.group(event);
+ }
+}