1 /*
   2  * Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package jdk.jfr.api.consumer;
  26 
  27 import java.nio.file.Path;
  28 import java.time.Duration;
  29 import java.util.ArrayList;
  30 import java.util.List;
  31 
  32 import jdk.jfr.Recording;
  33 import jdk.jfr.consumer.RecordedEvent;
  34 import jdk.jfr.consumer.RecordedFrame;
  35 import jdk.jfr.consumer.RecordedStackTrace;
  36 import jdk.jfr.consumer.RecordingFile;
  37 import jdk.test.lib.Asserts;
  38 import jdk.test.lib.Utils;
  39 import jdk.test.lib.jfr.EventNames;
  40 import jdk.test.lib.jfr.Events;
  41 import jdk.test.lib.jfr.RecurseThread;
  42 
  43 /**
  44  * @test
  45  * @key jfr
  46  *
  47  * @library /lib /
  48  * @run main/othervm jdk.jfr.api.consumer.TestRecordedFullStackTrace
  49  */
  50 public class TestRecordedFullStackTrace {
  51 
  52     private final static String EVENT_NAME = EventNames.ExecutionSample;
  53     private final static int MAX_DEPTH = 64; // currently hardcoded in jvm
  54 
  55     public static void main(String[] args) throws Throwable {
  56 
  57         RecurseThread[] threads = new RecurseThread[3];
  58         for (int i = 0; i < threads.length; ++i) {
  59             int depth = MAX_DEPTH - 1 + i;
  60             threads[i] = new RecurseThread(depth);
  61             threads[i].setName("recursethread-" + depth);
  62             threads[i].start();
  63         }
  64 
  65         for (RecurseThread thread : threads) {
  66             while (!thread.isInRunLoop()) {
  67                 Thread.sleep(20);
  68             }
  69         }
  70 
  71         assertStackTraces(threads);
  72 
  73         for (RecurseThread thread : threads) {
  74             thread.quit();
  75             thread.join();
  76         }
  77     }
  78 
  79     private static void assertStackTraces(RecurseThread[] threads) throws Throwable {
  80         Path path = null;
  81         do {
  82             Recording recording = new Recording();
  83             recording.enable(EVENT_NAME).withPeriod(Duration.ofMillis(50));
  84             recording.start();
  85             Thread.sleep(500);
  86             recording.stop();
  87             // Dump the recording to a file
  88             path = Utils.createTempFile("execution-stack-trace", ".jfr");
  89             System.out.println("Dumping to " + path);
  90             recording.dump(path);
  91             recording.close();
  92         } while (!hasValidStackTraces(path, threads));
  93     }
  94 
  95     private static boolean hasValidStackTraces(Path path, RecurseThread[] threads) throws Throwable {
  96         boolean[] isEventFound = new boolean[threads.length];
  97 
  98         for (RecordedEvent event : RecordingFile.readAllEvents(path)) {
  99             //System.out.println("Event: " + event);
 100             String threadName = Events.assertField(event, "sampledThread.javaName").getValue();
 101             long threadId = Events.assertField(event, "sampledThread.javaThreadId").getValue();
 102 
 103             for (int threadIndex = 0; threadIndex < threads.length; ++threadIndex) {
 104                 RecurseThread currThread = threads[threadIndex];
 105                 if (threadId == currThread.getId()) {
 106                     System.out.println("ThreadName=" + currThread.getName() + ", depth=" + currThread.totalDepth);
 107                     Asserts.assertEquals(threadName, currThread.getName(), "Wrong thread name");
 108                     if ("recurseEnd".equals(getTopMethodName(event))) {
 109                         isEventFound[threadIndex] = true;
 110                         checkEvent(event, currThread.totalDepth);
 111                         break;
 112                     }
 113                 }
 114             }
 115         }
 116 
 117         for (int i = 0; i < threads.length; ++i) {
 118             String msg = "threadIndex=%d, recurseDepth=%d, isEventFound=%b%n";
 119             System.out.printf(msg, i, threads[i].totalDepth, isEventFound[i]);
 120         }
 121         for (int i = 0; i < threads.length; ++i) {
 122             if (!isEventFound[i]) {
 123                // no assertion, let's retry.
 124                 // Could be race condition, i.e safe point during Thread.sleep
 125                 System.out.println("Falied to validate all threads, will retry.");
 126                 return false;
 127             }
 128         }
 129         return true;
 130     }
 131 
 132     public static String getTopMethodName(RecordedEvent event) {
 133         List<RecordedFrame> frames = event.getStackTrace().getFrames();
 134         Asserts.assertFalse(frames.isEmpty(), "JavaFrames was empty");
 135         return frames.get(0).getMethod().getName();
 136     }
 137 
 138     private static void checkEvent(RecordedEvent event, int expectedDepth) throws Throwable {
 139         RecordedStackTrace stacktrace = null;
 140         try {
 141             stacktrace = event.getStackTrace();
 142             List<RecordedFrame> frames = stacktrace.getFrames();
 143             Asserts.assertEquals(Math.min(MAX_DEPTH, expectedDepth), frames.size(), "Wrong stacktrace depth. Expected:" + expectedDepth);
 144             List<String> expectedMethods = getExpectedMethods(expectedDepth);
 145             Asserts.assertEquals(expectedMethods.size(), frames.size(), "Wrong expectedMethods depth. Test error.");
 146 
 147             for (int i = 0; i < frames.size(); ++i) {
 148                 String name = frames.get(i).getMethod().getName();
 149                 String expectedName = expectedMethods.get(i);
 150                 System.out.printf("method[%d]=%s, expected=%s%n", i, name, expectedName);
 151                 Asserts.assertEquals(name, expectedName, "Wrong method name");
 152             }
 153 
 154             boolean isTruncated = stacktrace.isTruncated();
 155             boolean isTruncateExpected = expectedDepth > MAX_DEPTH;
 156             Asserts.assertEquals(isTruncated, isTruncateExpected, "Wrong value for isTruncated. Expected:" + isTruncateExpected);
 157 
 158             String firstMethod = frames.get(frames.size() - 1).getMethod().getName();
 159             boolean isFullTrace = "run".equals(firstMethod);
 160             String msg = String.format("Wrong values for isTruncated=%b, isFullTrace=%b", isTruncated, isFullTrace);
 161             Asserts.assertTrue(isTruncated != isFullTrace, msg);
 162         } catch (Throwable t) {
 163             System.out.println(String.format("stacktrace:%n%s", stacktrace));
 164             throw t;
 165         }
 166     }
 167 
 168     private static List<String> getExpectedMethods(int depth) {
 169         List<String> methods = new ArrayList<>();
 170         methods.add("recurseEnd");
 171         for (int i = 0; i < depth - 2; ++i) {
 172             methods.add((i % 2) == 0 ? "recurseA" : "recurseB");
 173         }
 174         methods.add("run");
 175         if (depth > MAX_DEPTH) {
 176             methods = methods.subList(0, MAX_DEPTH);
 177         }
 178         return methods;
 179     }
 180 }