1 /*

     2  * Copyright (c) 2015, 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.event.gc.stacktrace;

    26 

    27 import javax.management.MBeanServer;

    28 import java.lang.management.ManagementFactory;

    29 import com.sun.management.GarbageCollectorMXBean;

    30 

    31 import jdk.jfr.Recording;

    32 import jdk.jfr.consumer.RecordedEvent;

    33 import jdk.jfr.consumer.RecordedStackTrace;

    34 import jdk.jfr.consumer.RecordedFrame;

    35 import jdk.jfr.consumer.RecordedMethod;

    36 import jdk.jfr.consumer.RecordedThread;

    37 import jdk.test.lib.jfr.EventNames;

    38 import jdk.test.lib.jfr.Events;

    39 

    40 import java.util.List;

    41 import java.util.ArrayList;

    42 

    43 import java.net.URL;

    44 import java.net.URLClassLoader;

    45 import java.lang.reflect.InvocationHandler;

    46 import java.lang.reflect.Method;

    47 import java.lang.reflect.Proxy;

    48 

    49 abstract class MemoryAllocator {

    50 

    51     public static final int KB = 1024;

    52     public static final int MB = 1024 * KB;

    53 

    54     public static Object garbage = null;

    55 

    56     abstract public void allocate();

    57     public void clear() {

    58         garbage = null;

    59     }

    60 }

    61 

    62 class EdenMemoryAllocator extends MemoryAllocator {

    63 

    64     @Override

    65     public void allocate() {

    66         garbage = new byte[10 * KB];

    67     }

    68 }

    69 

    70 class HumongousMemoryAllocator extends MemoryAllocator {

    71 

    72     @Override

    73     public void allocate() {

    74         garbage = new byte[5 * MB];

    75     }

    76 }

    77 

    78 /**

    79  * Attempts to fill up young gen and allocate in old gen

    80  */

    81 class OldGenMemoryAllocator extends MemoryAllocator {

    82 

    83     private List<byte[]> list = new ArrayList<byte[]>();

    84     private int counter = 6000;

    85 

    86     @Override

    87     public void allocate() {

    88         if (counter-- > 0) {

    89             list.add(new byte[10 * KB]);

    90         } else {

    91             list = new ArrayList<byte[]>();

    92             counter = 6000;

    93         }

    94 

    95         garbage = list;

    96     }

    97 

    98     @Override

    99     public void clear(){

   100         list = null;

   101         super.clear();

   102     }

   103 }

   104 

   105 class MetaspaceMemoryAllocator extends MemoryAllocator {

   106 

   107     private static int counter = 0;

   108 

   109     /**

   110      * Imitates class loading. Each invocation of this method causes a new class

   111      * loader object is created and a new class is loaded by this class loader.

   112      * Method throws OOM when run out of memory.

   113      */

   114     static protected void loadNewClass() {

   115         try {

   116             String jarUrl = "file:" + (counter++) + ".jar";

   117             URL[] urls = new URL[]{new URL(jarUrl)};

   118             URLClassLoader cl = new URLClassLoader(urls);

   119             Proxy.newProxyInstance(

   120                     cl,

   121                     new Class[]{Foo.class},

   122                     new FooInvocationHandler(new FooBar()));

   123         } catch (java.net.MalformedURLException badThing) {

   124             // should never occur

   125             System.err.println("Unexpected error: " + badThing);

   126             throw new RuntimeException(badThing);

   127         }

   128     }

   129 

   130     @Override

   131     public void allocate() {

   132         try {

   133             loadNewClass();

   134         } catch (OutOfMemoryError e) {

   135             /* empty */

   136         }

   137     }

   138 

   139     public static interface Foo {

   140     }

   141 

   142     public static class FooBar implements Foo {

   143     }

   144 

   145     static class FooInvocationHandler implements InvocationHandler {

   146 

   147         private final Foo foo;

   148 

   149         FooInvocationHandler(Foo foo) {

   150             this.foo = foo;

   151         }

   152 

   153         @Override

   154         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

   155             return method.invoke(foo, args);

   156         }

   157     }

   158 }

   159 

   160 /**

   161  * Utility class to peform JFR recording, GC provocation/detection and

   162  * stacktrace verification for related JFR events

   163  */

   164 public class AllocationStackTrace {

   165 

   166     /**

   167      * Tests event stacktrace for young GC if -XX:+UseSerialGC is used

   168      */

   169     public static void testDefNewAllocEvent() throws Exception {

   170         GarbageCollectorMXBean bean = garbageCollectorMXBean("Copy");

   171         MemoryAllocator memory = new EdenMemoryAllocator();

   172 

   173         String[] expectedStack = new String[]{

   174             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testAllocEvent",

   175             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testDefNewAllocEvent"

   176         };

   177 

   178         testAllocEvent(bean, memory, expectedStack);

   179     }

   180 

   181     /**

   182      * Tests event stacktrace for old GC if -XX:+UseSerialGC is used

   183      */

   184     public static void testMarkSweepCompactAllocEvent() throws Exception {

   185         GarbageCollectorMXBean bean = garbageCollectorMXBean("MarkSweepCompact");

   186         MemoryAllocator memory = new OldGenMemoryAllocator();

   187 

   188         String[] expectedStack = new String[]{

   189             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testAllocEvent",

   190             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testMarkSweepCompactAllocEvent"

   191         };

   192 

   193         testAllocEvent(bean, memory, expectedStack);

   194     }

   195 

   196     /**

   197      * Tests event stacktrace during metaspace GC threshold if -XX:+UseSerialGC

   198      * is used

   199      */

   200     public static void testMetaspaceSerialGCAllocEvent() throws Exception {

   201         GarbageCollectorMXBean bean = garbageCollectorMXBean("MarkSweepCompact");

   202         MemoryAllocator memory = new MetaspaceMemoryAllocator();

   203 

   204         String[] expectedStack = new String[]{

   205             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testAllocEvent",

   206             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testMetaspaceSerialGCAllocEvent"

   207         };

   208 

   209         testAllocEvent(bean, memory, expectedStack);

   210     }

   211 

   212     /**

   213      * Tests event stacktrace for young GC if -XX:+UseConcMarkSweepGC is used

   214      */

   215     public static void testParNewAllocEvent() throws Exception {

   216         GarbageCollectorMXBean bean = garbageCollectorMXBean("ParNew");

   217         MemoryAllocator memory = new EdenMemoryAllocator();

   218 

   219         String[] expectedStack = new String[]{

   220             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testAllocEvent",

   221             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testParNewAllocEvent"

   222         };

   223 

   224         testAllocEvent(bean, memory, expectedStack);

   225     }

   226 

   227     /**

   228      * Tests event stacktrace for old GC if -XX:+UseConcMarkSweepGC is used

   229      */

   230     public static void testConcMarkSweepAllocEvent() throws Exception {

   231         GarbageCollectorMXBean bean = garbageCollectorMXBean("ConcurrentMarkSweep");

   232         MemoryAllocator memory = new OldGenMemoryAllocator();

   233 

   234         String[] expectedStack = new String[]{

   235             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testAllocEvent",

   236             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testConcMarkSweepAllocEvent"

   237         };

   238 

   239         testAllocEvent(bean, memory, expectedStack);

   240     }

   241 

   242     /**

   243      * Tests event stacktrace during metaspace GC threshold if

   244      * -XX:+UseConcMarkSweepGC is used

   245      */

   246     public static void testMetaspaceConcMarkSweepGCAllocEvent() throws Exception {

   247         GarbageCollectorMXBean bean = garbageCollectorMXBean("ConcurrentMarkSweep");

   248         MemoryAllocator memory = new MetaspaceMemoryAllocator();

   249 

   250         String[] expectedStack = new String[]{

   251             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testAllocEvent",

   252             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testMetaspaceConcMarkSweepGCAllocEvent"

   253         };

   254 

   255         testAllocEvent(bean, memory, expectedStack);

   256     }

   257 

   258     /**

   259      * Tests event stacktrace for young GC if -XX:+UseParallelGC is used

   260      */

   261     public static void testParallelScavengeAllocEvent() throws Exception {

   262         GarbageCollectorMXBean bean = garbageCollectorMXBean("PS Scavenge");

   263         MemoryAllocator memory = new EdenMemoryAllocator();

   264 

   265         String[] expectedStack = new String[]{

   266             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testAllocEvent",

   267             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testParallelScavengeAllocEvent"

   268         };

   269 

   270         testAllocEvent(bean, memory, expectedStack);

   271     }

   272 

   273     /**

   274      * Tests event stacktrace for old GC if -XX:+UseParallelGC is used

   275      */

   276     public static void testParallelMarkSweepAllocEvent() throws Exception {

   277         GarbageCollectorMXBean bean = garbageCollectorMXBean("PS MarkSweep");

   278         MemoryAllocator memory = new OldGenMemoryAllocator();

   279 

   280         String[] expectedStack = new String[]{

   281             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testAllocEvent",

   282             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testParallelMarkSweepAllocEvent"

   283         };

   284 

   285         testAllocEvent(bean, memory, expectedStack);

   286     }

   287 

   288     /**

   289      * Tests event stacktrace during metaspace GC threshold if

   290      * -XX:+UseParallelGC is used

   291      */

   292     public static void testMetaspaceParallelGCAllocEvent() throws Exception {

   293         GarbageCollectorMXBean bean = garbageCollectorMXBean("PS MarkSweep");

   294         MemoryAllocator memory = new MetaspaceMemoryAllocator();

   295 

   296         String[] expectedStack = new String[]{

   297             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testAllocEvent",

   298             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testMetaspaceParallelGCAllocEvent"

   299         };

   300 

   301         testAllocEvent(bean, memory, expectedStack);

   302     }

   303 

   304     /**

   305      * Tests event stacktrace for young GC if -XX:+UseG1GC is used

   306      */

   307     public static void testG1YoungAllocEvent() throws Exception {

   308         GarbageCollectorMXBean bean = garbageCollectorMXBean("G1 Young Generation");

   309         MemoryAllocator memory = new EdenMemoryAllocator();

   310 

   311         String[] expectedStack = new String[]{

   312             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testAllocEvent",

   313             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testG1YoungAllocEvent"

   314         };

   315 

   316         testAllocEvent(bean, memory, expectedStack);

   317     }

   318 

   319     /**

   320      * Tests event stacktrace for old GC if -XX:+UseG1GC is used

   321      */

   322     public static void testG1OldAllocEvent() throws Exception {

   323         GarbageCollectorMXBean bean = garbageCollectorMXBean("G1 Old Generation");

   324         MemoryAllocator memory = new OldGenMemoryAllocator();

   325 

   326         String[] expectedStack = new String[]{

   327             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testAllocEvent",

   328             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testG1OldAllocEvent"

   329         };

   330 

   331         testAllocEvent(bean, memory, expectedStack);

   332     }

   333 

   334     /**

   335      * Tests event stacktrace during metaspace GC threshold if -XX:+UseG1GC is

   336      * used

   337      */

   338     public static void testMetaspaceG1GCAllocEvent() throws Exception {

   339         GarbageCollectorMXBean bean = garbageCollectorMXBean("G1 Young Generation");

   340         MemoryAllocator memory = new MetaspaceMemoryAllocator();

   341 

   342         String[] expectedStack = new String[]{

   343             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testAllocEvent",

   344             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testMetaspaceG1GCAllocEvent"

   345         };

   346 

   347         testAllocEvent(bean, memory, expectedStack);

   348     }

   349 

   350     /**

   351      * Tests event stacktrace for GC caused by humongous allocations if

   352      * -XX:+UseG1GC is used

   353      */

   354     public static void testG1HumonAllocEvent() throws Exception {

   355         // G1 tries to reclaim humongous objects at every young collection

   356         // after doing a conservative estimate of its liveness

   357         GarbageCollectorMXBean bean = garbageCollectorMXBean("G1 Young Generation");

   358         MemoryAllocator memory = new HumongousMemoryAllocator();

   359 

   360         String[] expectedStack = new String[]{

   361             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testAllocEvent",

   362             "jdk.jfr.event.gc.stacktrace.AllocationStackTrace.testG1HumonAllocEvent"

   363         };

   364 

   365         testAllocEvent(bean, memory, expectedStack);

   366     }

   367 

   368     private static GarbageCollectorMXBean garbageCollectorMXBean(String name) throws Exception {

   369         MBeanServer server = ManagementFactory.getPlatformMBeanServer();

   370         GarbageCollectorMXBean bean = ManagementFactory.newPlatformMXBeanProxy(

   371                 server, "java.lang:type=GarbageCollector,name=" + name, GarbageCollectorMXBean.class);

   372         return bean;

   373     }

   374 

   375     /**

   376      * Performs JFR recording, GC provocation/detection and stacktrace

   377      * verification for JFR event. In case of verification failure

   378      * repeats several times.

   379      *

   380      * @param bean MX bean for desired GC

   381      * @param memory allocator for desired type of allocations

   382      * @param expectedStack array of expected frames

   383      */

   384     private static void testAllocEvent(GarbageCollectorMXBean bean, MemoryAllocator memory, String[] expectedStack) throws Exception {

   385         // The test checks the stacktrace of events and expects all the events are fired

   386         // in the current thread. But compilation may also trigger GC.

   387         // So to filter out such cases the test performs several iterations and expects

   388         // that the memory allocations made by the test will produce the desired JFR event.

   389         final int iterations = 5;

   390         for (int i = 0; i < iterations; i++) {

   391             if (allocAndCheck(bean, memory, expectedStack)) {

   392                 return;

   393             } else {

   394                 System.out.println("Attempt: " + i + " out of " + iterations+": no matching stack trace found.");

   395             }

   396             memory.clear();

   397         }

   398         throw new AssertionError("No matching stack trace found");

   399     }

   400 

   401     /**

   402      * Performs JFR recording, GC provocation/detection and stacktrace

   403      * verification for JFR event.

   404      *

   405      * @param bean MX bean for desired GC

   406      * @param memory allocator for desired type of allocations

   407      * @param expectedStack array of expected frames

   408      * @throws Exception

   409      */

   410     private static boolean allocAndCheck(GarbageCollectorMXBean bean, MemoryAllocator memory,

   411             String[] expectedStack) throws Exception {

   412         String threadName = Thread.currentThread().getName();

   413         String event = EventNames.AllocationRequiringGC;

   414 

   415         Recording r = new Recording();

   416         r.enable(event).withStackTrace();

   417         r.start();

   418 

   419         long prevCollectionCount = bean.getCollectionCount();

   420         long collectionCount = -1;

   421 

   422         long iterationCount = 0;

   423 

   424         do {

   425             memory.allocate();

   426             collectionCount = bean.getCollectionCount();

   427             iterationCount++;

   428         } while (collectionCount == prevCollectionCount);

   429 

   430         System.out.println("Allocation num: " + iterationCount);

   431         System.out.println("GC detected: " + collectionCount);

   432 

   433         r.stop();

   434         List<RecordedEvent> events = Events.fromRecording(r);

   435 

   436         System.out.println("JFR GC events found: " + events.size());

   437 

   438         // Find any event that matched the expected stack trace

   439         for (RecordedEvent e : events) {

   440             System.out.println("Event: " + e);

   441             RecordedThread thread = e.getThread();

   442             String eventThreadName = thread.getJavaName();

   443             if (!threadName.equals(eventThreadName)) {

   444                 continue;

   445             }

   446             if (matchingStackTrace(e.getStackTrace(), expectedStack)) {

   447                 return true;

   448             }

   449         }

   450         return false;

   451     }

   452 

   453     private static boolean matchingStackTrace(RecordedStackTrace stack, String[] expectedStack) {

   454         if (stack == null) {

   455             return false;

   456         }

   457 

   458         List<RecordedFrame> frames = stack.getFrames();

   459         int pos = findFramePos(frames, expectedStack[0]);

   460 

   461         if (pos == -1) {

   462             return false;

   463         }

   464 

   465         for (String expectedFrame : expectedStack) {

   466             RecordedFrame f = frames.get(pos++);

   467             String frame = frameToString(f);

   468 

   469             if (!frame.equals(expectedFrame)) {

   470                 return false;

   471             }

   472         }

   473 

   474         return true;

   475     }

   476 

   477     private static int findFramePos(List<RecordedFrame> frames, String frame) {

   478         int pos = 0;

   479 

   480         for (RecordedFrame f : frames) {

   481             if (frame.equals(frameToString(f))) {

   482                 return pos;

   483             }

   484             pos++;

   485         }

   486 

   487         return -1;

   488     }

   489 

   490     private static String frameToString(RecordedFrame f) {

   491         RecordedMethod m = f.getMethod();

   492         String methodName = m.getName();

   493         String className = m.getType().getName();

   494         return className + "." + methodName;

   495     }

   496 

   497 }