author | egahlin |
Mon, 05 Nov 2018 14:40:16 +0100 | |
changeset 52413 | 6372f5af9612 |
parent 52334 | a181612f0715 |
child 58570 | 12bf92ce7991 |
permissions | -rw-r--r-- |
50113 | 1 |
/* |
2 |
* Copyright (c) 2016, 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.internal; |
|
27 |
||
28 |
import java.io.IOException; |
|
29 |
import java.lang.annotation.Annotation; |
|
30 |
import java.lang.annotation.Repeatable; |
|
31 |
import java.lang.reflect.Field; |
|
32 |
import java.lang.reflect.InvocationTargetException; |
|
33 |
import java.lang.reflect.Method; |
|
34 |
import java.lang.reflect.Modifier; |
|
35 |
import java.util.ArrayDeque; |
|
36 |
import java.util.ArrayList; |
|
37 |
import java.util.Collection; |
|
38 |
import java.util.Collections; |
|
39 |
import java.util.HashMap; |
|
40 |
import java.util.HashSet; |
|
41 |
import java.util.LinkedHashMap; |
|
42 |
import java.util.List; |
|
43 |
import java.util.Map; |
|
44 |
import java.util.Queue; |
|
45 |
import java.util.Set; |
|
46 |
import java.util.function.Consumer; |
|
47 |
import java.util.function.Predicate; |
|
48 |
import java.util.stream.Stream; |
|
49 |
||
50 |
import jdk.jfr.AnnotationElement; |
|
51 |
import jdk.jfr.Description; |
|
52 |
import jdk.jfr.Label; |
|
53 |
import jdk.jfr.MetadataDefinition; |
|
54 |
import jdk.jfr.Name; |
|
55 |
import jdk.jfr.SettingDescriptor; |
|
56 |
import jdk.jfr.Timespan; |
|
57 |
import jdk.jfr.Timestamp; |
|
58 |
import jdk.jfr.ValueDescriptor; |
|
59 |
||
60 |
public final class TypeLibrary { |
|
61 |
||
62 |
private static TypeLibrary instance; |
|
63 |
private static final Map<Long, Type> types = new LinkedHashMap<>(100); |
|
64 |
static final ValueDescriptor DURATION_FIELD = createDurationField(); |
|
65 |
static final ValueDescriptor THREAD_FIELD = createThreadField(); |
|
66 |
static final ValueDescriptor STACK_TRACE_FIELD = createStackTraceField(); |
|
67 |
static final ValueDescriptor START_TIME_FIELD = createStartTimeField(); |
|
68 |
||
69 |
private TypeLibrary(List<Type> jvmTypes) { |
|
70 |
visitReachable(jvmTypes, t -> !types.containsKey(t.getId()), t -> types.put(t.getId(), t)); |
|
52413 | 71 |
if (Logger.shouldLog(LogTag.JFR_SYSTEM_METADATA, LogLevel.INFO)) { |
50113 | 72 |
Stream<Type> s = types.values().stream().sorted((x, y) -> Long.compare(x.getId(), y.getId())); |
73 |
s.forEach(t -> t.log("Added", LogTag.JFR_SYSTEM_METADATA, LogLevel.INFO)); |
|
74 |
} |
|
75 |
} |
|
76 |
||
77 |
private static ValueDescriptor createStartTimeField() { |
|
78 |
List<AnnotationElement> annos = createStandardAnnotations("Start Time", null); |
|
79 |
annos.add(new jdk.jfr.AnnotationElement(Timestamp.class, Timestamp.TICKS)); |
|
80 |
return PrivateAccess.getInstance().newValueDescriptor(EventInstrumentation.FIELD_START_TIME, Type.LONG, annos, 0, false, |
|
81 |
EventInstrumentation.FIELD_START_TIME); |
|
82 |
||
83 |
} |
|
84 |
||
85 |
private static ValueDescriptor createStackTraceField() { |
|
86 |
List<AnnotationElement> annos = new ArrayList<>(); |
|
87 |
annos = createStandardAnnotations("Stack Trace", "Stack Trace starting from the method the event was committed in"); |
|
88 |
return PrivateAccess.getInstance().newValueDescriptor(EventInstrumentation.FIELD_STACK_TRACE, Type.STACK_TRACE, annos, 0, true, |
|
89 |
EventInstrumentation.FIELD_STACK_TRACE); |
|
90 |
} |
|
91 |
||
92 |
private static ValueDescriptor createThreadField() { |
|
93 |
List<AnnotationElement> annos = new ArrayList<>(); |
|
94 |
annos = createStandardAnnotations("Event Thread", "Thread in which event was committed in"); |
|
95 |
return PrivateAccess.getInstance().newValueDescriptor(EventInstrumentation.FIELD_EVENT_THREAD, Type.THREAD, annos, 0, true, |
|
96 |
EventInstrumentation.FIELD_EVENT_THREAD); |
|
97 |
} |
|
98 |
||
99 |
private static ValueDescriptor createDurationField() { |
|
100 |
List<AnnotationElement> annos = new ArrayList<>(); |
|
101 |
annos = createStandardAnnotations("Duration", null); |
|
102 |
annos.add(new jdk.jfr.AnnotationElement(Timespan.class, Timespan.TICKS)); |
|
103 |
return PrivateAccess.getInstance().newValueDescriptor(EventInstrumentation.FIELD_DURATION, Type.LONG, annos, 0, false, EventInstrumentation.FIELD_DURATION); |
|
104 |
} |
|
105 |
||
106 |
public static TypeLibrary getInstance() { |
|
107 |
synchronized (TypeLibrary.class) { |
|
108 |
if (instance == null) { |
|
109 |
List<Type> jvmTypes; |
|
110 |
try { |
|
111 |
jvmTypes = MetadataHandler.createTypes(); |
|
112 |
Collections.sort(jvmTypes, (a,b) -> Long.compare(a.getId(), b.getId())); |
|
113 |
} catch (IOException e) { |
|
114 |
throw new Error("JFR: Could not read metadata"); |
|
115 |
} |
|
116 |
instance = new TypeLibrary(jvmTypes); |
|
117 |
} |
|
118 |
return instance; |
|
119 |
} |
|
120 |
} |
|
121 |
||
122 |
public List<Type> getTypes() { |
|
123 |
return new ArrayList<>(types.values()); |
|
124 |
} |
|
125 |
||
126 |
public static Type createAnnotationType(Class<? extends Annotation> a) { |
|
127 |
if (shouldPersist(a)) { |
|
128 |
Type type = defineType(a, Type.SUPER_TYPE_ANNOTATION, false); |
|
129 |
if (type != null) { |
|
130 |
SecuritySupport.makeVisibleToJFR(a); |
|
131 |
for (Method method : a.getDeclaredMethods()) { |
|
132 |
type.add(PrivateAccess.getInstance().newValueDescriptor(method.getReturnType(), method.getName())); |
|
133 |
} |
|
134 |
ArrayList<AnnotationElement> aes = new ArrayList<>(); |
|
135 |
for (Annotation annotation : resolveRepeatedAnnotations(a.getAnnotations())) { |
|
136 |
AnnotationElement ae = createAnnotation(annotation); |
|
137 |
if (ae != null) { |
|
138 |
aes.add(ae); |
|
139 |
} |
|
140 |
} |
|
141 |
aes.trimToSize(); |
|
142 |
type.setAnnotations(aes); |
|
143 |
} |
|
144 |
return getType(a); |
|
145 |
} |
|
146 |
return null; |
|
147 |
} |
|
148 |
||
149 |
static AnnotationElement createAnnotation(Annotation annotation) { |
|
150 |
Class<? extends Annotation> annotationType = annotation.annotationType(); |
|
151 |
Type type = createAnnotationType(annotationType); |
|
152 |
if (type != null) { |
|
153 |
List<Object> values = new ArrayList<>(); |
|
154 |
for (ValueDescriptor v : type.getFields()) { |
|
155 |
values.add(invokeAnnotation(annotation, v.getName())); |
|
156 |
} |
|
157 |
||
158 |
return PrivateAccess.getInstance().newAnnotation(type, values, annotation.annotationType().getClassLoader() == null); |
|
159 |
} |
|
160 |
return null; |
|
161 |
} |
|
162 |
||
163 |
private static Object invokeAnnotation(Annotation annotation, String methodName) { |
|
164 |
final Method m; |
|
165 |
try { |
|
166 |
m = annotation.getClass().getMethod(methodName, new Class<?>[0]); |
|
167 |
} catch (NoSuchMethodException e1) { |
|
168 |
throw (Error) new InternalError("Could not loacate method " + methodName + " in annotation " + annotation.getClass().getName()); |
|
169 |
} |
|
170 |
SecuritySupport.setAccessible(m); |
|
171 |
try { |
|
172 |
return m.invoke(annotation, new Object[0]); |
|
173 |
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { |
|
174 |
throw (Error) new InternalError("Could not get value for method " + methodName + " in annotation " + annotation.getClass().getName()); |
|
175 |
} |
|
176 |
} |
|
177 |
||
178 |
private static boolean shouldPersist(Class<? extends Annotation> a) { |
|
179 |
if (a == MetadataDefinition.class || a.getAnnotation(MetadataDefinition.class) == null) { |
|
180 |
return false; |
|
181 |
} |
|
182 |
return true; |
|
183 |
} |
|
184 |
||
185 |
private static boolean isDefined(Class<?> clazz) { |
|
186 |
return types.containsKey(Type.getTypeId(clazz)); |
|
187 |
} |
|
188 |
||
189 |
private static Type getType(Class<?> clazz) { |
|
190 |
return types.get(Type.getTypeId(clazz)); |
|
191 |
} |
|
192 |
||
193 |
private static Type defineType(Class<?> clazz, String superType, boolean eventType) { |
|
194 |
if (!isDefined(clazz)) { |
|
195 |
Name name = clazz.getAnnotation(Name.class); |
|
196 |
String typeName = name != null ? name.value() : clazz.getName(); |
|
197 |
long id = Type.getTypeId(clazz); |
|
198 |
Type t; |
|
199 |
if (eventType) { |
|
200 |
t = new PlatformEventType(typeName, id, clazz.getClassLoader() == null, true); |
|
201 |
} else { |
|
202 |
t = new Type(typeName, superType, id); |
|
203 |
} |
|
204 |
types.put(t.getId(), t); |
|
205 |
return t; |
|
206 |
} |
|
207 |
return null; |
|
208 |
} |
|
209 |
public static Type createType(Class<?> clazz) { |
|
210 |
return createType(clazz, Collections.emptyList(), Collections.emptyList()); |
|
211 |
} |
|
212 |
||
213 |
public static Type createType(Class<?> clazz, List<AnnotationElement> dynamicAnnotations, List<ValueDescriptor> dynamicFields) { |
|
214 |
||
215 |
if (Thread.class == clazz) { |
|
216 |
return Type.THREAD; |
|
217 |
} |
|
218 |
||
219 |
if (Class.class.isAssignableFrom(clazz)) { |
|
220 |
return Type.CLASS; |
|
221 |
} |
|
222 |
||
223 |
if (String.class.equals(clazz)) { |
|
224 |
return Type.STRING; |
|
225 |
} |
|
226 |
||
227 |
if (isDefined(clazz)) { |
|
228 |
return getType(clazz); |
|
229 |
} |
|
230 |
||
231 |
if (clazz.isPrimitive()) { |
|
232 |
return defineType(clazz, null,false); |
|
233 |
} |
|
234 |
||
235 |
if (clazz.isArray()) { |
|
236 |
throw new InternalError("Arrays not supported"); |
|
237 |
} |
|
238 |
||
239 |
// STRUCT |
|
240 |
String superType = null; |
|
241 |
boolean eventType = false; |
|
52334
a181612f0715
8203629: Produce events in the JDK without a dependency on jdk.jfr
egahlin
parents:
50113
diff
changeset
|
242 |
if (jdk.internal.event.Event.class.isAssignableFrom(clazz)) { |
50113 | 243 |
superType = Type.SUPER_TYPE_EVENT; |
244 |
eventType= true; |
|
245 |
} |
|
246 |
if (Control.class.isAssignableFrom(clazz)) { |
|
247 |
superType = Type.SUPER_TYPE_SETTING; |
|
248 |
} |
|
249 |
||
250 |
// forward declare to avoid infinite recursion |
|
251 |
defineType(clazz, superType, eventType); |
|
252 |
Type type = getType(clazz); |
|
253 |
||
254 |
if (eventType) { |
|
255 |
addImplicitFields(type, true, true, true, true ,false); |
|
256 |
addUserFields(clazz, type, dynamicFields); |
|
257 |
type.trimFields(); |
|
258 |
} |
|
259 |
addAnnotations(clazz, type, dynamicAnnotations); |
|
260 |
||
261 |
if (clazz.getClassLoader() == null) { |
|
262 |
type.log("Added", LogTag.JFR_SYSTEM_METADATA, LogLevel.INFO); |
|
263 |
} else { |
|
264 |
type.log("Added", LogTag.JFR_METADATA, LogLevel.INFO); |
|
265 |
} |
|
266 |
return type; |
|
267 |
} |
|
268 |
||
269 |
private static void addAnnotations(Class<?> clazz, Type type, List<AnnotationElement> dynamicAnnotations) { |
|
270 |
ArrayList<AnnotationElement> aes = new ArrayList<>(); |
|
271 |
if (dynamicAnnotations.isEmpty()) { |
|
272 |
for (Annotation a : Utils.getAnnotations(clazz)) { |
|
273 |
AnnotationElement ae = createAnnotation(a); |
|
274 |
if (ae != null) { |
|
275 |
aes.add(ae); |
|
276 |
} |
|
277 |
} |
|
278 |
} else { |
|
279 |
List<Type> newTypes = new ArrayList<>(); |
|
280 |
aes.addAll(dynamicAnnotations); |
|
281 |
for (AnnotationElement ae : dynamicAnnotations) { |
|
282 |
newTypes.add(PrivateAccess.getInstance().getType(ae)); |
|
283 |
} |
|
284 |
addTypes(newTypes); |
|
285 |
} |
|
286 |
type.setAnnotations(aes); |
|
287 |
aes.trimToSize(); |
|
288 |
} |
|
289 |
||
290 |
private static void addUserFields(Class<?> clazz, Type type, List<ValueDescriptor> dynamicFields) { |
|
291 |
Map<String, ValueDescriptor> dynamicFieldSet = new HashMap<>(); |
|
292 |
for (ValueDescriptor dynamicField : dynamicFields) { |
|
293 |
dynamicFieldSet.put(dynamicField.getName(), dynamicField); |
|
294 |
} |
|
295 |
List<Type> newTypes = new ArrayList<>(); |
|
296 |
for (Field field : Utils.getVisibleEventFields(clazz)) { |
|
297 |
ValueDescriptor vd = dynamicFieldSet.get(field.getName()); |
|
298 |
if (vd != null) { |
|
299 |
if (!vd.getTypeName().equals(field.getType().getName())) { |
|
300 |
throw new InternalError("Type expected to match for field " + vd.getName() + " expected " + field.getName() + " but got " + vd.getName()); |
|
301 |
} |
|
302 |
for (AnnotationElement ae : vd.getAnnotationElements()) { |
|
303 |
newTypes.add(PrivateAccess.getInstance().getType(ae)); |
|
304 |
} |
|
305 |
newTypes.add(PrivateAccess.getInstance().getType(vd)); |
|
306 |
} else { |
|
307 |
vd = createField(field); |
|
308 |
} |
|
309 |
if (vd != null) { |
|
310 |
type.add(vd); |
|
311 |
} |
|
312 |
} |
|
313 |
addTypes(newTypes); |
|
314 |
} |
|
315 |
||
316 |
// By convention all events have these fields. |
|
317 |
static void addImplicitFields(Type type, boolean requestable, boolean hasDuration, boolean hasThread, boolean hasStackTrace, boolean hasCutoff) { |
|
318 |
createAnnotationType(Timespan.class); |
|
319 |
createAnnotationType(Timestamp.class); |
|
320 |
createAnnotationType(Label.class); |
|
321 |
defineType(long.class, null,false); |
|
322 |
addFields(type, requestable, hasDuration, hasThread, hasStackTrace, hasCutoff); |
|
323 |
} |
|
324 |
||
325 |
private static void addFields(Type type, boolean requestable, boolean hasDuration, boolean hasThread, boolean hasStackTrace, boolean hasCutoff) { |
|
326 |
type.add(START_TIME_FIELD); |
|
327 |
if (hasDuration || hasCutoff) { |
|
328 |
type.add(DURATION_FIELD); |
|
329 |
} |
|
330 |
if (hasThread) { |
|
331 |
type.add(THREAD_FIELD); |
|
332 |
} |
|
333 |
if (hasStackTrace) { |
|
334 |
type.add(STACK_TRACE_FIELD); |
|
335 |
} |
|
336 |
} |
|
337 |
||
338 |
private static List<AnnotationElement> createStandardAnnotations(String name, String description) { |
|
339 |
List<AnnotationElement> annotationElements = new ArrayList<>(2); |
|
340 |
annotationElements.add(new jdk.jfr.AnnotationElement(Label.class, name)); |
|
341 |
if (description != null) { |
|
342 |
annotationElements.add(new jdk.jfr.AnnotationElement(Description.class, description)); |
|
343 |
} |
|
344 |
return annotationElements; |
|
345 |
} |
|
346 |
||
347 |
private static ValueDescriptor createField(Field field) { |
|
348 |
int mod = field.getModifiers(); |
|
349 |
if (Modifier.isTransient(mod)) { |
|
350 |
return null; |
|
351 |
} |
|
352 |
if (Modifier.isStatic(mod)) { |
|
353 |
return null; |
|
354 |
} |
|
355 |
Class<?> fieldType = field.getType(); |
|
356 |
if (!Type.isKnownType(fieldType)) { |
|
357 |
return null; |
|
358 |
} |
|
359 |
boolean constantPool = Thread.class == fieldType || fieldType == Class.class; |
|
360 |
Type type = createType(fieldType); |
|
361 |
String fieldName = field.getName(); |
|
362 |
Name name = field.getAnnotation(Name.class); |
|
363 |
String useName = fieldName; |
|
364 |
if (name != null) { |
|
365 |
useName = name.value(); |
|
366 |
} |
|
367 |
List<jdk.jfr.AnnotationElement> ans = new ArrayList<>(); |
|
368 |
for (Annotation a : resolveRepeatedAnnotations(field.getAnnotations())) { |
|
369 |
AnnotationElement ae = createAnnotation(a); |
|
370 |
if (ae != null) { |
|
371 |
ans.add(ae); |
|
372 |
} |
|
373 |
} |
|
374 |
return PrivateAccess.getInstance().newValueDescriptor(useName, type, ans, 0, constantPool, fieldName); |
|
375 |
} |
|
376 |
||
377 |
private static List<Annotation> resolveRepeatedAnnotations(Annotation[] annotations) { |
|
378 |
List<Annotation> annos = new ArrayList<>(annotations.length); |
|
379 |
for (Annotation a : annotations) { |
|
380 |
boolean repeated = false; |
|
381 |
Method m; |
|
382 |
try { |
|
383 |
m = a.annotationType().getMethod("value"); |
|
384 |
Class<?> returnType = m.getReturnType(); |
|
385 |
if (returnType.isArray()) { |
|
386 |
Class<?> ct = returnType.getComponentType(); |
|
387 |
if (Annotation.class.isAssignableFrom(ct) && ct.getAnnotation(Repeatable.class) != null) { |
|
388 |
Object res = m.invoke(a, new Object[0]); |
|
389 |
if (res != null && Annotation[].class.isAssignableFrom(res.getClass())) { |
|
390 |
for (Annotation rep : (Annotation[]) m.invoke(a, new Object[0])) { |
|
391 |
annos.add(rep); |
|
392 |
} |
|
393 |
repeated = true; |
|
394 |
} |
|
395 |
} |
|
396 |
} |
|
397 |
} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { |
|
398 |
// Ignore, can't access repeatable information |
|
399 |
} |
|
400 |
if (!repeated) { |
|
401 |
annos.add(a); |
|
402 |
} |
|
403 |
} |
|
404 |
return annos; |
|
405 |
} |
|
406 |
||
407 |
// Purpose of this method is to mark types that are reachable |
|
408 |
// from registered event types. Those types that are not reachable can |
|
409 |
// safely be removed |
|
410 |
public boolean clearUnregistered() { |
|
411 |
Logger.log(LogTag.JFR_METADATA, LogLevel.TRACE, "Cleaning out obsolete metadata"); |
|
412 |
List<Type> registered = new ArrayList<>(); |
|
413 |
for (Type type : types.values()) { |
|
414 |
if (type instanceof PlatformEventType) { |
|
415 |
if (((PlatformEventType) type).isRegistered()) { |
|
416 |
registered.add(type); |
|
417 |
} |
|
418 |
} |
|
419 |
} |
|
420 |
visitReachable(registered, t -> t.getRemove(), t -> t.setRemove(false)); |
|
421 |
List<Long> removeIds = new ArrayList<>(); |
|
422 |
for (Type type : types.values()) { |
|
423 |
if (type.getRemove() && !Type.isDefinedByJVM(type.getId())) { |
|
424 |
removeIds.add(type.getId()); |
|
52413 | 425 |
if (Logger.shouldLog(LogTag.JFR_METADATA, LogLevel.TRACE)) { |
50113 | 426 |
Logger.log(LogTag.JFR_METADATA, LogLevel.TRACE, "Removed obsolete metadata " + type.getName()); |
427 |
} |
|
428 |
} |
|
429 |
// Optimization, set to true now to avoid iterating |
|
430 |
// types first thing at next call to clearUnregistered |
|
431 |
type.setRemove(true); |
|
432 |
} |
|
433 |
for (Long id : removeIds) { |
|
434 |
types.remove(id); |
|
435 |
} |
|
436 |
return !removeIds.isEmpty(); |
|
437 |
} |
|
438 |
||
439 |
public void addType(Type type) { |
|
440 |
addTypes(Collections.singletonList(type)); |
|
441 |
} |
|
442 |
||
443 |
public static void addTypes(List<Type> ts) { |
|
444 |
if (!ts.isEmpty()) { |
|
445 |
visitReachable(ts, t -> !types.containsKey(t.getId()), t -> types.put(t.getId(), t)); |
|
446 |
} |
|
447 |
} |
|
448 |
||
449 |
/** |
|
450 |
* Iterates all reachable types from a start collection |
|
451 |
* |
|
452 |
* @param rootSet the types to start from |
|
453 |
* @param p if a type should be accepted |
|
454 |
* @param c action to take on an accepted type |
|
455 |
*/ |
|
456 |
private static void visitReachable(Collection<Type> rootSet, Predicate<Type> p, Consumer<Type> c) { |
|
457 |
Queue<Type> typeQ = new ArrayDeque<>(rootSet); |
|
458 |
while (!typeQ.isEmpty()) { |
|
459 |
Type type = typeQ.poll(); |
|
460 |
if (p.test(type)) { |
|
461 |
c.accept(type); |
|
462 |
visitAnnotations(typeQ, type.getAnnotationElements()); |
|
463 |
for (ValueDescriptor v : type.getFields()) { |
|
464 |
typeQ.add(PrivateAccess.getInstance().getType(v)); |
|
465 |
visitAnnotations(typeQ, v.getAnnotationElements()); |
|
466 |
} |
|
467 |
if (type instanceof PlatformEventType) { |
|
468 |
PlatformEventType pe = (PlatformEventType) type; |
|
469 |
for (SettingDescriptor s : pe.getAllSettings()) { |
|
470 |
typeQ.add(PrivateAccess.getInstance().getType(s)); |
|
471 |
visitAnnotations(typeQ, s.getAnnotationElements()); |
|
472 |
} |
|
473 |
} |
|
474 |
} |
|
475 |
} |
|
476 |
} |
|
477 |
||
478 |
private static void visitAnnotations(Queue<Type> typeQ, List<AnnotationElement> aes) { |
|
479 |
Queue<AnnotationElement> aQ = new ArrayDeque<>(aes); |
|
480 |
Set<AnnotationElement> visited = new HashSet<>(); |
|
481 |
while (!aQ.isEmpty()) { |
|
482 |
AnnotationElement ae = aQ.poll(); |
|
483 |
if (!visited.contains(ae)) { |
|
484 |
Type ty = PrivateAccess.getInstance().getType(ae); |
|
485 |
typeQ.add(ty); |
|
486 |
visited.add(ae); |
|
487 |
} |
|
488 |
aQ.addAll(ae.getAnnotationElements()); |
|
489 |
} |
|
490 |
} |
|
52334
a181612f0715
8203629: Produce events in the JDK without a dependency on jdk.jfr
egahlin
parents:
50113
diff
changeset
|
491 |
|
a181612f0715
8203629: Produce events in the JDK without a dependency on jdk.jfr
egahlin
parents:
50113
diff
changeset
|
492 |
public void removeType(long id) { |
a181612f0715
8203629: Produce events in the JDK without a dependency on jdk.jfr
egahlin
parents:
50113
diff
changeset
|
493 |
types.remove(id); |
a181612f0715
8203629: Produce events in the JDK without a dependency on jdk.jfr
egahlin
parents:
50113
diff
changeset
|
494 |
} |
50113 | 495 |
} |