1 /*

     2  * Copyright (c) 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 

    26 package jdk.jfr.jvm;

    27 

    28 import java.io.File;

    29 import java.io.IOException;

    30 import java.time.Duration;

    31 import java.util.ArrayList;

    32 import java.util.List;

    33 

    34 import jdk.jfr.AnnotationElement;

    35 import jdk.jfr.Event;

    36 import jdk.jfr.EventType;

    37 import jdk.jfr.FlightRecorder;

    38 import jdk.jfr.Recording;

    39 import jdk.jfr.ValueDescriptor;

    40 import jdk.jfr.consumer.RecordedEvent;

    41 import jdk.jfr.consumer.RecordingFile;

    42 

    43 /*

    44  * @test TestGetThreadId

    45  * @key jfr

    46  * @library /test/lib

    47  * @modules jdk.jfr/jdk.jfr.internal

    48  * @run main/othervm jdk.jfr.jvm.TestJavaEvent

    49  */

    50 public class TestJavaEvent {

    51 

    52     private static final int EVENTS_PER_THREAD = 50;

    53     private static final int THREAD_COUNT = 100;

    54 

    55     public static class MyEvent extends Event {

    56         float floatValue;

    57         double doubleValue;

    58         int intValue;

    59         long longValue;

    60         char charValue;

    61         byte byteValue;

    62         String stringValue;

    63         Thread threadValue;

    64         Class<?> classValue;

    65 

    66         public void setFloatValue(float value) {

    67             floatValue = value;

    68         }

    69 

    70         public void setDoubleValue(double value) {

    71             doubleValue = value;

    72         }

    73 

    74         public void setIntValue(int value) {

    75             intValue = value;

    76         }

    77 

    78         public void setLongValue(long value) {

    79             longValue = value;

    80         }

    81 

    82         public void setCharValue(char value) {

    83             charValue = value;

    84         }

    85 

    86         public void setByteValue(byte value) {

    87             byteValue = value;

    88         }

    89 

    90         public void setStringValue(String value) {

    91             stringValue = value;

    92         }

    93 

    94         public void setThreadValue(Thread value) {

    95             threadValue = value;

    96         }

    97 

    98         public void setClassValue(Class<?> value) {

    99             classValue = value;

   100         }

   101     }

   102 

   103     public static void main(String... args) throws IOException, InterruptedException {

   104         Recording r = new Recording();

   105         r.enable(MyEvent.class).withThreshold(Duration.ofNanos(0)).withoutStackTrace();

   106         r.start();

   107         List<Thread> threads = new ArrayList<>();

   108         for (int n = 0; n < THREAD_COUNT; n++) {

   109             Thread t = new Thread(TestJavaEvent::emitEvents);

   110             threads.add(t);

   111             t.start();

   112         }

   113         for (Thread t : threads) {

   114             t.join();

   115         }

   116 

   117         r.stop();

   118         // prettyPrint();

   119         File file = File.createTempFile("test", ".jfr");

   120         r.dump(file.toPath());

   121         int eventCount = 0;

   122         for (RecordedEvent e : RecordingFile.readAllEvents(file.toPath())) {

   123             if (e.getEventType().getName().equals(MyEvent.class.getName())) {

   124                 eventCount++;

   125             }

   126             System.out.println(e);

   127         }

   128         System.out.println("Event count was " + eventCount + ", expected " + THREAD_COUNT * EVENTS_PER_THREAD);

   129         r.close();

   130     }

   131 

   132     private static void emitEvents() {

   133         for (int n = 0; n < EVENTS_PER_THREAD; n++) {

   134             MyEvent event = new MyEvent();

   135             event.begin();

   136             event.end();

   137             event.setFloatValue(1.12345f);

   138             event.setDoubleValue(1.234567890);

   139             event.setIntValue(123456);

   140             event.setLongValue(1234567890);

   141             event.setCharValue('c');

   142             event.setByteValue((byte) 12);

   143             event.setStringValue("1234567890");

   144             event.setThreadValue(Thread.currentThread());

   145             event.setClassValue(Class.class);

   146             event.commit();

   147             try {

   148                 Thread.sleep(1);

   149             } catch (InterruptedException e) {

   150                 // TODO Auto-generated catch block

   151                 e.printStackTrace();

   152             }

   153         }

   154     }

   155 

   156     static void prettyPrint() {

   157         for (EventType type : FlightRecorder.getFlightRecorder().getEventTypes()) {

   158             for (AnnotationElement a : type.getAnnotationElements()) {

   159                 printAnnotation("", a);

   160             }

   161             System.out.print("class " + removePackage(type.getName()));

   162             System.out.print(" extends Event");

   163 

   164             System.out.println(" {");

   165             List<ValueDescriptor> values = type.getFields();

   166             for (int i = 0; i < values.size(); i++) {

   167                 ValueDescriptor v = values.get(i);

   168                 for (AnnotationElement a : v.getAnnotationElements()) {

   169                     printAnnotation("  ", a);

   170                 }

   171                 System.out.println("  " + removePackage(v.getTypeName() + brackets(v.isArray())) + " " + v.getName());

   172                 if (i != values.size() - 1) {

   173                     System.out.println();

   174                 }

   175             }

   176             System.out.println("}");

   177             System.out.println();

   178         }

   179     }

   180 

   181     private static String brackets(boolean isArray) {

   182         return isArray ? "[]" : "";

   183     }

   184 

   185     private static String removePackage(String s) {

   186 

   187         int index = s.lastIndexOf(".");

   188         return s.substring(index + 1);

   189     }

   190 

   191     private static void printAnnotation(String indent, AnnotationElement a) {

   192         String name = removePackage(a.getTypeName());

   193         if (a.getValues().isEmpty()) {

   194             System.out.println(indent + "@" + name);

   195             return;

   196         }

   197         System.out.print(indent + "@" + name + "(");

   198         for (Object o : a.getValues()) {

   199             printAnnotationValue(o);

   200         }

   201         System.out.println(")");

   202     }

   203 

   204     private static void printAnnotationValue(Object o) {

   205         if (o instanceof String) {

   206             System.out.print("\"" + o + "\"");

   207         } else {

   208             System.out.print(String.valueOf(o));

   209         }

   210     }

   211 

   212 }