< prev index next >

core/org.openjdk.jmc.flightrecorder/src/main/java/org/openjdk/jmc/flightrecorder/internal/parser/v1/TypeManager.java

Print this page




 102                 @Override
 103                 public void addEvent(Object[] fieldValues) {
 104                         Iterator<Integer> skipIter = skipFields.iterator();
 105                         int skipNext = skipIter.next();
 106                         int j = 0;
 107                         for (int i = 0; i < fieldValues.length; i++) {
 108                                 if (i != skipNext) {
 109                                         reusableStruct[j++] = fieldValues[i];
 110                                 } else if (skipIter.hasNext()) {
 111                                         skipNext = skipIter.next();
 112                                 }
 113                         }
 114                         subSink.addEvent(reusableStruct);
 115                 }
 116         }
 117 
 118         // NOTE: Using constant pool id as identifier.
 119         private static final Map<Long, StructContentType<Object[]>> STRUCT_TYPES = new HashMap<>();
 120 
 121         private class TypeEntry {


 122                 private static final String STRUCT_TYPE_STACK_TRACE = "com.oracle.jfr.types.StackTrace"; //$NON-NLS-1$

 123                 private static final String STRUCT_TYPE_STACK_FRAME = "com.oracle.jfr.types.StackFrame"; //$NON-NLS-1$

 124                 private static final String STRUCT_TYPE_METHOD = "com.oracle.jfr.types.Method"; //$NON-NLS-1$
 125                 private static final String STRUCT_TYPE_CLASS = "java.lang.Class"; //$NON-NLS-1$
 126                 private static final String STRUCT_TYPE_CLASS_LOADER = "com.oracle.jfr.types.ClassLoader"; //$NON-NLS-1$

 127                 private static final String STRUCT_TYPE_MODULE = "com.oracle.jfr.types.Module"; //$NON-NLS-1$

 128                 private static final String STRUCT_TYPE_PACKAGE = "com.oracle.jfr.types.Package"; //$NON-NLS-1$

 129                 private static final String STRUCT_TYPE_OLD_OBJECT = "com.oracle.jfr.types.OldObject"; //$NON-NLS-1$

 130                 private static final String STRUCT_TYPE_OLD_OBJECT_ARRAY = "com.oracle.jfr.types.OldObjectArray"; //$NON-NLS-1$

 131                 private static final String STRUCT_TYPE_OLD_OBJECT_FIELD = "com.oracle.jfr.types.OldObjectField"; //$NON-NLS-1$

 132                 private static final String STRUCT_TYPE_OLD_OBJECT_GC_ROOT = "com.oracle.jfr.types.OldObjectGcRoot"; //$NON-NLS-1$

 133                 private static final String STRUCT_TYPE_THREAD_GROUP = "com.oracle.jfr.types.ThreadGroup"; //$NON-NLS-1$
 134                 private static final String STRUCT_TYPE_THREAD = "java.lang.Thread"; //$NON-NLS-1$
 135 
 136                 final ClassElement element;
 137                 final FastAccessNumberMap<Object> constants;
 138                 private IValueReader reader;
 139 
 140                 TypeEntry(ClassElement element) {
 141                         this(element, new FastAccessNumberMap<>());
 142                 }
 143 
 144                 /**
 145                  * Temporary constructor for sharing constants. Only used for Strings.
 146                  */
 147                 TypeEntry(ClassElement element, FastAccessNumberMap<Object> constants) {
 148                         this.element = element;
 149                         this.constants = constants;
 150                 }
 151 
 152                 public IValueReader getReader() throws InvalidJfrFileException {
 153                         if (reader == null) {
 154                                 int fieldCount = element.getFieldCount();
 155                                 if (element.isSimpleType() && fieldCount == 1) {
 156                                         FieldElement singleField = element.fields.get(0);
 157                                         if (singleField.classId == element.classId) {
 158                                                 throw new InvalidJfrFileException(
 159                                                                 element.typeIdentifier + " is a simple type referring to itself"); //$NON-NLS-1$
 160                                         } else {
 161                                                 reader = createFieldReader(element.fields.get(0), null);
 162                                         }
 163                                 } else if (fieldCount == 0 && element.superType == null) {
 164                                         if (StringReader.STRING.equals(element.typeIdentifier)) {
 165                                                 reader = new StringReader(constants);
 166                                         } else {
 167                                                 reader = new PrimitiveReader(element.typeIdentifier);
 168                                         }
 169                                 } else {
 170                                         AbstractStructReader typeReader = createStructReader(element.typeIdentifier, element.label,
 171                                                         element.description, fieldCount);



 172                                         // assign before resolving field since it may be recursive
 173                                         reader = typeReader;
 174                                         for (int i = 0; i < fieldCount; i++) {
 175                                                 FieldElement fe = element.fields.get(i);
 176                                                 IValueReader reader = createFieldReader(fe, null);
 177                                                 String labelOrId = (fe.label == null) ? fe.fieldIdentifier : fe.label;
 178                                                 typeReader.addField(fe.fieldIdentifier, labelOrId, fe.description, reader);
 179                                         }
 180                                 }
 181                         }
 182                         return reader;
 183                 }
 184 
 185                 private AbstractStructReader createStructReader(






































 186                         String identifier, String name, String description, int fieldCount) {
 187                         switch (identifier) {
 188                         case STRUCT_TYPE_THREAD:
 189                                 return new ReflectiveReader(JfrThread.class, fieldCount, UnitLookup.THREAD);
 190                         case STRUCT_TYPE_THREAD_GROUP:
 191                                 return new ReflectiveReader(JfrThreadGroup.class, fieldCount, UnitLookup.THREAD_GROUP);
 192                         case STRUCT_TYPE_CLASS:
 193                                 return new ReflectiveReader(JfrJavaClass.class, fieldCount, UnitLookup.CLASS);
 194                         case STRUCT_TYPE_CLASS_LOADER:
 195                                 return new ReflectiveReader(JfrJavaClassLoader.class, fieldCount, UnitLookup.CLASS_LOADER);
 196                         case STRUCT_TYPE_OLD_OBJECT_GC_ROOT:
 197                                 return new ReflectiveReader(JfrOldObjectGcRoot.class, fieldCount, UnitLookup.OLD_OBJECT_GC_ROOT);
 198                         case STRUCT_TYPE_OLD_OBJECT:
 199                                 return new ReflectiveReader(JfrOldObject.class, fieldCount, UnitLookup.OLD_OBJECT);
 200                         case STRUCT_TYPE_OLD_OBJECT_ARRAY:
 201                                 return new ReflectiveReader(JfrOldObjectArray.class, fieldCount, UnitLookup.OLD_OBJECT_ARRAY);
 202                         case STRUCT_TYPE_OLD_OBJECT_FIELD:
 203                                 return new ReflectiveReader(JfrOldObjectField.class, fieldCount, UnitLookup.OLD_OBJECT_FIELD);
 204                         case STRUCT_TYPE_METHOD:
 205                                 return new ReflectiveReader(JfrMethod.class, fieldCount, UnitLookup.METHOD);




 102                 @Override
 103                 public void addEvent(Object[] fieldValues) {
 104                         Iterator<Integer> skipIter = skipFields.iterator();
 105                         int skipNext = skipIter.next();
 106                         int j = 0;
 107                         for (int i = 0; i < fieldValues.length; i++) {
 108                                 if (i != skipNext) {
 109                                         reusableStruct[j++] = fieldValues[i];
 110                                 } else if (skipIter.hasNext()) {
 111                                         skipNext = skipIter.next();
 112                                 }
 113                         }
 114                         subSink.addEvent(reusableStruct);
 115                 }
 116         }
 117 
 118         // NOTE: Using constant pool id as identifier.
 119         private static final Map<Long, StructContentType<Object[]>> STRUCT_TYPES = new HashMap<>();
 120 
 121         private class TypeEntry {
 122                 private static final String STRUCT_TYPE_CLASS = "java.lang.Class"; //$NON-NLS-1$
 123                 private static final String STRUCT_TYPE_THREAD = "java.lang.Thread"; //$NON-NLS-1$
 124                 private static final String STRUCT_TYPE_STACK_TRACE = "com.oracle.jfr.types.StackTrace"; //$NON-NLS-1$
 125                 private static final String STRUCT_TYPE_STACK_TRACE_2 = "jdk.types.StackTrace"; //$NON-NLS-1$
 126                 private static final String STRUCT_TYPE_STACK_FRAME = "com.oracle.jfr.types.StackFrame"; //$NON-NLS-1$
 127                 private static final String STRUCT_TYPE_STACK_FRAME_2 = "jdk.types.StackFrame"; //$NON-NLS-1$
 128                 private static final String STRUCT_TYPE_METHOD = "com.oracle.jfr.types.Method"; //$NON-NLS-1$
 129                 private static final String STRUCT_TYPE_METHOD_2 = "jdk.types.Method"; //$NON-NLS-1$
 130                 private static final String STRUCT_TYPE_CLASS_LOADER = "com.oracle.jfr.types.ClassLoader"; //$NON-NLS-1$
 131                 private static final String STRUCT_TYPE_CLASS_LOADER_2 = "jdk.types.ClassLoader"; //$NON-NLS-1$
 132                 private static final String STRUCT_TYPE_MODULE = "com.oracle.jfr.types.Module"; //$NON-NLS-1$
 133                 private static final String STRUCT_TYPE_MODULE_2 = "jdk.types.Module"; //$NON-NLS-1$
 134                 private static final String STRUCT_TYPE_PACKAGE = "com.oracle.jfr.types.Package"; //$NON-NLS-1$
 135                 private static final String STRUCT_TYPE_PACKAGE_2 = "jdk.types.Package"; //$NON-NLS-1$
 136                 private static final String STRUCT_TYPE_OLD_OBJECT = "com.oracle.jfr.types.OldObject"; //$NON-NLS-1$
 137                 private static final String STRUCT_TYPE_OLD_OBJECT_2 = "jdk.types.OldObject"; //$NON-NLS-1$
 138                 private static final String STRUCT_TYPE_OLD_OBJECT_ARRAY = "com.oracle.jfr.types.OldObjectArray"; //$NON-NLS-1$
 139                 private static final String STRUCT_TYPE_OLD_OBJECT_ARRAY_2 = "jdk.types.OldObjectArray"; //$NON-NLS-1$
 140                 private static final String STRUCT_TYPE_OLD_OBJECT_FIELD = "com.oracle.jfr.types.OldObjectField"; //$NON-NLS-1$
 141                 private static final String STRUCT_TYPE_OLD_OBJECT_FIELD_2 = "jdk.types.OldObjectField"; //$NON-NLS-1$
 142                 private static final String STRUCT_TYPE_OLD_OBJECT_GC_ROOT = "com.oracle.jfr.types.OldObjectGcRoot"; //$NON-NLS-1$
 143                 private static final String STRUCT_TYPE_OLD_OBJECT_GC_ROOT_2 = "jdk.types.OldObjectGcRoot"; //$NON-NLS-1$
 144                 private static final String STRUCT_TYPE_THREAD_GROUP = "com.oracle.jfr.types.ThreadGroup"; //$NON-NLS-1$
 145                 private static final String STRUCT_TYPE_THREAD_GROUP_2 = "jdk.types.ThreadGroup"; //$NON-NLS-1$
 146 
 147                 final ClassElement element;
 148                 final FastAccessNumberMap<Object> constants;
 149                 private IValueReader reader;
 150 
 151                 TypeEntry(ClassElement element) {
 152                         this(element, new FastAccessNumberMap<>());
 153                 }
 154 
 155                 /**
 156                  * Temporary constructor for sharing constants. Only used for Strings.
 157                  */
 158                 TypeEntry(ClassElement element, FastAccessNumberMap<Object> constants) {
 159                         this.element = element;
 160                         this.constants = constants;
 161                 }
 162 
 163                 public IValueReader getReader() throws InvalidJfrFileException {
 164                         if (reader == null) {
 165                                 int fieldCount = element.getFieldCount();
 166                                 if (element.isSimpleType() && fieldCount == 1) {
 167                                         FieldElement singleField = element.fields.get(0);
 168                                         if (singleField.classId == element.classId) {
 169                                                 throw new InvalidJfrFileException(
 170                                                                 element.typeIdentifier + " is a simple type referring to itself"); //$NON-NLS-1$
 171                                         } else {
 172                                                 reader = createFieldReader(element.fields.get(0), null);
 173                                         }
 174                                 } else if (fieldCount == 0 && element.superType == null) {
 175                                         if (StringReader.STRING.equals(element.typeIdentifier)) {
 176                                                 reader = new StringReader(constants);
 177                                         } else {
 178                                                 reader = new PrimitiveReader(element.typeIdentifier);
 179                                         }
 180                                 } else {
 181                                         AbstractStructReader typeReader = element.typeIdentifier.startsWith("jdk.") //$NON-NLS-1$
 182                                                         ? createStructReaderV2(element.typeIdentifier, element.label, element.description,
 183                                                                         fieldCount)
 184                                                         : createStructReaderV1(element.typeIdentifier, element.label, element.description,
 185                                                                         fieldCount);
 186                                         // assign before resolving field since it may be recursive
 187                                         reader = typeReader;
 188                                         for (int i = 0; i < fieldCount; i++) {
 189                                                 FieldElement fe = element.fields.get(i);
 190                                                 IValueReader reader = createFieldReader(fe, null);
 191                                                 String labelOrId = (fe.label == null) ? fe.fieldIdentifier : fe.label;
 192                                                 typeReader.addField(fe.fieldIdentifier, labelOrId, fe.description, reader);
 193                                         }
 194                                 }
 195                         }
 196                         return reader;
 197                 }
 198 
 199                 private AbstractStructReader createStructReaderV2(
 200                         String identifier, String name, String description, int fieldCount) {
 201                         switch (identifier) {
 202                         case STRUCT_TYPE_THREAD_GROUP_2:
 203                                 return new ReflectiveReader(JfrThreadGroup.class, fieldCount, UnitLookup.THREAD_GROUP);
 204                         case STRUCT_TYPE_CLASS_LOADER_2:
 205                                 return new ReflectiveReader(JfrJavaClassLoader.class, fieldCount, UnitLookup.CLASS_LOADER);
 206                         case STRUCT_TYPE_OLD_OBJECT_GC_ROOT_2:
 207                                 return new ReflectiveReader(JfrOldObjectGcRoot.class, fieldCount, UnitLookup.OLD_OBJECT_GC_ROOT);
 208                         case STRUCT_TYPE_OLD_OBJECT_2:
 209                                 return new ReflectiveReader(JfrOldObject.class, fieldCount, UnitLookup.OLD_OBJECT);
 210                         case STRUCT_TYPE_OLD_OBJECT_ARRAY_2:
 211                                 return new ReflectiveReader(JfrOldObjectArray.class, fieldCount, UnitLookup.OLD_OBJECT_ARRAY);
 212                         case STRUCT_TYPE_OLD_OBJECT_FIELD_2:
 213                                 return new ReflectiveReader(JfrOldObjectField.class, fieldCount, UnitLookup.OLD_OBJECT_FIELD);
 214                         case STRUCT_TYPE_METHOD_2:
 215                                 return new ReflectiveReader(JfrMethod.class, fieldCount, UnitLookup.METHOD);
 216                         case STRUCT_TYPE_STACK_FRAME_2:
 217                                 return new ReflectiveReader(JfrFrame.class, fieldCount, UnitLookup.STACKTRACE_FRAME);
 218                         case STRUCT_TYPE_STACK_TRACE_2:
 219                                 return new ReflectiveReader(JfrStackTrace.class, fieldCount, UnitLookup.STACKTRACE);
 220                         case STRUCT_TYPE_MODULE_2:
 221                                 return new ReflectiveReader(JfrJavaModule.class, fieldCount, UnitLookup.MODULE);
 222                         case STRUCT_TYPE_PACKAGE_2:
 223                                 return new ReflectiveReader(JfrJavaPackage.class, fieldCount, UnitLookup.PACKAGE);
 224                         default:
 225                                 synchronized (STRUCT_TYPES) {
 226                                         StructContentType<Object[]> structType = STRUCT_TYPES.get(element.classId);
 227                                         if (structType == null) {
 228                                                 structType = new StructContentType<>(element.typeIdentifier, element.label,
 229                                                                 element.description);
 230                                                 STRUCT_TYPES.put(element.classId, structType);
 231                                         }
 232                                         return new StructReader(structType, fieldCount);
 233                                 }
 234                         }
 235                 }
 236 
 237                 private AbstractStructReader createStructReaderV1(
 238                         String identifier, String name, String description, int fieldCount) {
 239                         switch (identifier) {
 240                         case STRUCT_TYPE_THREAD:
 241                                 return new ReflectiveReader(JfrThread.class, fieldCount, UnitLookup.THREAD);
 242                         case STRUCT_TYPE_THREAD_GROUP:
 243                                 return new ReflectiveReader(JfrThreadGroup.class, fieldCount, UnitLookup.THREAD_GROUP);
 244                         case STRUCT_TYPE_CLASS:
 245                                 return new ReflectiveReader(JfrJavaClass.class, fieldCount, UnitLookup.CLASS);
 246                         case STRUCT_TYPE_CLASS_LOADER:
 247                                 return new ReflectiveReader(JfrJavaClassLoader.class, fieldCount, UnitLookup.CLASS_LOADER);
 248                         case STRUCT_TYPE_OLD_OBJECT_GC_ROOT:
 249                                 return new ReflectiveReader(JfrOldObjectGcRoot.class, fieldCount, UnitLookup.OLD_OBJECT_GC_ROOT);
 250                         case STRUCT_TYPE_OLD_OBJECT:
 251                                 return new ReflectiveReader(JfrOldObject.class, fieldCount, UnitLookup.OLD_OBJECT);
 252                         case STRUCT_TYPE_OLD_OBJECT_ARRAY:
 253                                 return new ReflectiveReader(JfrOldObjectArray.class, fieldCount, UnitLookup.OLD_OBJECT_ARRAY);
 254                         case STRUCT_TYPE_OLD_OBJECT_FIELD:
 255                                 return new ReflectiveReader(JfrOldObjectField.class, fieldCount, UnitLookup.OLD_OBJECT_FIELD);
 256                         case STRUCT_TYPE_METHOD:
 257                                 return new ReflectiveReader(JfrMethod.class, fieldCount, UnitLookup.METHOD);


< prev index next >