Examples with ClassSegmentIterator com.ibm.j9ddr.vm29.j9.walkers.ClassSegmentIterator used on opensource projects

Example 1 with ClassSegmentIterator

use of com.ibm.j9ddr.vm29.j9.walkers.ClassSegmentIterator in project openj9 by eclipse.

the class DumpAllRamClassLinearCommand method run.

public void run(String command, String[] args, Context context, PrintStream out) throws DDRInteractiveCommandException {
    long nestingThreashold;
    if (args.length > 1) {
        throw new DDRInteractiveCommandException("This debug extension accepts none or one argument!");
    } else if (args.length == 1) {
        nestingThreashold = Long.valueOf(args[0]);
    } else {
        nestingThreashold = 1;
    }
    try {
        J9JavaVMPointer vm = J9RASHelper.getVM(DataType.getJ9RASPointer());
        if (null != vm) {
            out.println();
            out.println("!j9javavm " + vm.getHexAddress());
        } else {
            throw new DDRInteractiveCommandException("Unable to find the VM in core dump!");
        }
        out.println();
        ClassSegmentIterator classSegmentIterator = new ClassSegmentIterator(vm.classMemorySegments());
        while (classSegmentIterator.hasNext()) {
            J9ClassPointer classPointer = (J9ClassPointer) classSegmentIterator.next();
            out.println("!dumpramclasslinear " + classPointer.getHexAddress());
            // RAM Class 'org/apache/tomcat/util/buf/MessageBytes' at 0x0DCF9008:
            out.println(String.format("RAM Class '%s' at %s", J9ClassHelper.getJavaName(classPointer), classPointer.getHexAddress()));
            out.println();
            ClassWalker classWalker = new RamClassWalker(classPointer, context);
            new LinearDumper().gatherLayoutInfo(out, classWalker, nestingThreashold);
            out.println();
        }
    } catch (CorruptDataException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }
}

Example 2 with ClassSegmentIterator

use of com.ibm.j9ddr.vm29.j9.walkers.ClassSegmentIterator in project openj9 by eclipse.

the class ClassloadersSummaryCommand method getStat.

public Collection<ClassloadersSummaryNode> getStat() throws CorruptDataException {
    Map<J9ClassLoaderPointer, Counter> classloadersCount = new HashMap<J9ClassLoaderPointer, Counter>();
    J9JavaVMPointer vm = J9RASHelper.getVM(DataType.getJ9RASPointer());
    GCClassLoaderIterator iterator = GCClassLoaderIterator.from();
    while (iterator.hasNext()) {
        J9ClassLoaderPointer classLoader = iterator.next();
        classloadersCount.put(classLoader, new Counter(0));
    }
    /* Iterate through all classes and count how many were loaded by each classLoader */
    ClassSegmentIterator classSegmentIterator = new ClassSegmentIterator(vm.classMemorySegments());
    while (classSegmentIterator.hasNext()) {
        J9ClassPointer classPointer = (J9ClassPointer) classSegmentIterator.next();
        Counter counter = classloadersCount.get(classPointer.classLoader());
        if (counter != null) {
            counter.addOne();
        } else {
            classloadersCount.put(classPointer.classLoader(), new Counter(1));
        }
    }
    J9ObjectPointer sys = vm.systemClassLoader().classLoaderObject();
    final UDATA valueROM = new UDATA(J9MemorySegment.MEMORY_TYPE_ROM_CLASS);
    final UDATA valueRAM = new UDATA(J9MemorySegment.MEMORY_TYPE_RAM_CLASS);
    Map<String, ClassloadersSummaryNode> classloaders = new LinkedHashMap<String, ClassloadersSummaryNode>();
    for (Map.Entry<J9ClassLoaderPointer, Counter> entry : classloadersCount.entrySet()) {
        J9ObjectPointer classLoaderObject = entry.getKey().classLoaderObject();
        boolean isSystem = classLoaderObject.equals(sys);
        String loader = isSystem ? "*System*" : J9ObjectHelper.getClassName(classLoaderObject);
        /*	For each classloader, iterate through each associated memory segment and identify whether it is  
			 * 	a ROM or a RAM type memory segment  */
        long romSegmentCount = 0;
        long ramSegmentCount = 0;
        long romSegmentAllocatedMem = 0;
        long ramSegmentAllocatedMem = 0;
        J9MemorySegmentPointer segment = entry.getKey().classSegments();
        while (segment.notNull()) {
            if ((segment.type().bitAnd(valueROM)).equals(valueROM)) {
                romSegmentCount += 1;
                romSegmentAllocatedMem += segment.size().longValue();
            } else if ((segment.type().bitAnd(valueRAM)).equals(valueRAM)) {
                ramSegmentCount += 1;
                ramSegmentAllocatedMem += segment.size().longValue();
            }
            segment = segment.nextSegmentInClassLoader();
        }
        ClassloadersSummaryNode cpentry = classloaders.get(loader);
        if (cpentry == null) {
            // If the classLoader is not in the list, add it with "# Classloaders = 1" and "# Loaded Classes = classesLoaded"
            classloaders.put(loader, new ClassloadersSummaryNode(loader, 1L, entry.getValue().getCount(), ramSegmentCount, romSegmentCount, romSegmentAllocatedMem, ramSegmentAllocatedMem));
        } else {
            // If the classLoader is in the list, increment "# Classloaders" by 1 and increment "# Loaded Classes" by classesLoaded
            cpentry.numClassloaders += 1;
            cpentry.numLoadedClasses += entry.getValue().getCount();
            cpentry.ramSegmentCounter += ramSegmentCount;
            cpentry.romSegmentCounter += romSegmentCount;
            cpentry.totalROMSegmentAllocatedMemory += romSegmentAllocatedMem;
            cpentry.totalRAMSegmentAllocatedMemory += ramSegmentAllocatedMem;
        }
    }
    return classloaders.values();
}

Example 3 with ClassSegmentIterator

use of com.ibm.j9ddr.vm29.j9.walkers.ClassSegmentIterator in project openj9 by eclipse.

the class DumpRomClassCommand method run.

public void run(String command, String[] args, Context context, PrintStream out) throws DDRInteractiveCommandException {
    try {
        long maps = 0;
        if (args.length != 1 && args.length != 2) {
            printUsage(out);
            return;
        }
        if (args.length == 2 && args[1].equals("maps")) {
            maps |= J9BCTranslationData.BCT_DumpMaps;
        }
        if (J9BuildFlags.env_littleEndian) {
            maps |= J9BCTranslationData.BCT_LittleEndianOutput;
        } else {
            maps |= J9BCTranslationData.BCT_BigEndianOutput;
        }
        /* check for name:<name> */
        if (args[0].startsWith("name:")) {
            long hitCount = 0;
            String searchClassName = args[0].substring(args[0].indexOf(':') + 1);
            PatternString pattern = new PatternString(searchClassName);
            J9JavaVMPointer vm = J9RASHelper.getVM(DataType.getJ9RASPointer());
            ClassSegmentIterator iterator = new ClassSegmentIterator(vm.classMemorySegments());
            while (iterator.hasNext()) {
                J9ClassPointer classPointer = (J9ClassPointer) iterator.next();
                String javaName = J9ClassHelper.getJavaName(classPointer);
                if (pattern.isMatch(javaName)) {
                    hitCount++;
                    J9ROMClassPointer clazz = classPointer.romClass();
                    String hexString = clazz.getHexAddress();
                    out.println(String.format("ROMClass %1$s named %2$s\n", hexString, javaName));
                    J9BCUtil.j9bcutil_dumpRomClass(out, clazz, maps);
                }
            }
            out.println(String.format("Found %1$d class(es) with name %2$s\n", hitCount, searchClassName));
        } else {
            /* treat argument as address */
            long addr = CommandUtils.parsePointer(args[0], J9BuildFlags.env_data64);
            J9ROMClassPointer clazz = J9ROMClassPointer.cast(addr);
            J9BCUtil.j9bcutil_dumpRomClass(out, clazz, maps);
        }
    } catch (CorruptDataException e) {
        throw new DDRInteractiveCommandException(e);
    }
}

Example 4 with ClassSegmentIterator

use of com.ibm.j9ddr.vm29.j9.walkers.ClassSegmentIterator in project openj9 by eclipse.

the class J9ClassShapeCommand method findClassByName.

public static J9ClassPointer[] findClassByName(J9JavaVMPointer vm, String searchClassName) throws DDRInteractiveCommandException {
    ArrayList<J9ClassPointer> result = new ArrayList<J9ClassPointer>();
    try {
        PatternString pattern = new PatternString(searchClassName);
        ClassSegmentIterator classSegmentIterator = new ClassSegmentIterator(vm.classMemorySegments());
        while (classSegmentIterator.hasNext()) {
            J9ClassPointer classPointer = (J9ClassPointer) classSegmentIterator.next();
            String javaName = J9ClassHelper.getJavaName(classPointer);
            if (pattern.isMatch(javaName)) {
                result.add(classPointer);
            }
        }
    } catch (CorruptDataException e) {
        throw new DDRInteractiveCommandException(e);
    }
    return result.toArray(new J9ClassPointer[result.size()]);
}

Example 5 with ClassSegmentIterator

use of com.ibm.j9ddr.vm29.j9.walkers.ClassSegmentIterator in project openj9 by eclipse.

the class RomClassSummaryCommand method run.

public void run(String command, String[] args, Context context, PrintStream out) throws DDRInteractiveCommandException {
    try {
        boolean requiredLocal = false;
        boolean requiredShared = false;
        boolean required16bitnas = false;
        J9SharedClassConfigPointer sc = J9SharedClassConfigPointer.NULL;
        J9JavaVMPointer vm = J9RASHelper.getVM(DataType.getJ9RASPointer());
        long startAddress = 0, endAddress = 0;
        if ((args != null) && (args.length >= 1)) {
            if (args[0].equals("shared")) {
                requiredShared = true;
            } else if (args[0].equals("local")) {
                requiredLocal = true;
            } else if (args[0].equals("16bitnas")) {
                required16bitnas = true;
            } else {
                out.println("USAGE: !romclasssummary [local|shared] [16bitnas]");
                return;
            }
            if ((args.length >= 2) && (args[1].equals("16bitnas"))) {
                required16bitnas = true;
            }
            if (requiredShared || requiredLocal) {
                sc = vm.sharedClassConfig();
                if (requiredShared && sc.isNull()) {
                    out.println("The request for '" + args[0] + " classes' failed, because " + "shared classes were not enabled on that dump file.");
                    return;
                }
                if (sc.notNull()) {
                    startAddress = UDATA.cast(sc.cacheDescriptorList().romclassStartAddress()).longValue();
                    J9SharedCacheHeaderPointer header = sc.cacheDescriptorList().cacheStartAddress();
                    endAddress = UDATA.cast(header).add(header.segmentSRP()).longValue();
                }
            }
        }
        ClassSummaryHelper classSummaryHelper = new ClassSummaryHelper(preferredOrder);
        Statistics statistics = new Statistics();
        ROMClassesIterator classSegmentIterator = new ROMClassesIterator(out, vm.classMemorySegments());
        while (classSegmentIterator.hasNext()) {
            J9ROMClassPointer classPointer = (J9ROMClassPointer) classSegmentIterator.next();
            if (requiredShared || requiredLocal) {
                boolean isShared;
                if (sc.notNull()) {
                    long classAddress = classPointer.getAddress();
                    isShared = classAddress >= startAddress && classAddress < endAddress;
                } else {
                    isShared = false;
                }
                if (requiredShared && !isShared)
                    continue;
                if (requiredLocal && isShared)
                    continue;
            }
            ClassWalker classWalker = new RomClassWalker(classPointer, context);
            LinearDumper linearDumper = new LinearDumper();
            J9ClassRegionNode allRegionsNode = linearDumper.getAllRegions(classWalker);
            classSummaryHelper.addRegionsForClass(allRegionsNode);
            if (required16bitnas) {
                statistics.add(allRegionsNode);
            }
        }
        classSummaryHelper.printStatistics(out);
        if (statistics.nameAndSignatureSRP16bitSize != -1) {
            out.println();
            out.println("<Total 16bit nameAndSignatureSRPs Size>");
            out.println(statistics.nameAndSignatureSRP16bitSize);
        }
        if (statistics.nameAndSignatureSRPCount != -1 && statistics.cpFieldNASCount != -1) {
            out.println();
            out.println("<Shared nameAndSignatureSRPs>");
            // nameAndSignatureSRPCount is divided by 2, because there is a name and a signature per NAS field
            out.println(statistics.cpFieldNASCount - statistics.nameAndSignatureSRPCount / 2);
        }
    } catch (CorruptDataException e) {
        throw new DDRInteractiveCommandException(e);
    }
}