Examples with J9ThreadPointer com.ibm.j9ddr.vm29.pointer.generated.J9ThreadPointer used on opensource projects

Example 11 with J9ThreadPointer

use of com.ibm.j9ddr.vm29.pointer.generated.J9ThreadPointer in project openj9 by eclipse.

the class MonitorsCommand method writeSystemMonitorToBuffer.

/**
 * Helper to write details for a system monitor to a buffer.
 *
 * @param filter
 * @param monitor
 * @param out
 * @throws CorruptDataException
 */
private void writeSystemMonitorToBuffer(FilterOptions filter, SystemMonitor monitor, StringBuilder out) throws CorruptDataException {
    if (filter.shouldPrint(monitor)) {
        out.append(String.format("%s\t%s\n", monitor.getRawMonitor().formatShortInteractive(), monitor.getName()));
        // Step 1: Check for owner:
        J9ThreadPointer ownerPtr = monitor.getOwner();
        if (!ownerPtr.isNull()) {
            out.append(String.format("\tOwner:\t%s\n", ownerPtr.formatShortInteractive()));
        }
        // Step 2: Check if there are blocked (enter waiters) threads:
        List<String> blockedThreads = threadsListHelper(monitor.getBlockedThreads());
        if (!blockedThreads.isEmpty()) {
            out.append("\tBlocking (Enter Waiter):\n");
            for (String aThread : blockedThreads) {
                out.append(String.format("\t\t%s\n", aThread));
            }
        }
        // Step 3: Check if there are waiting (notify waiters) threads:
        List<String> notifyThreads = threadsListHelper(monitor.getWaitingThreads());
        if (!notifyThreads.isEmpty()) {
            out.append("\tWaiting (Notify Waiter):\n");
            for (String aThread : notifyThreads) {
                out.append(String.format("\t\t%s\n", aThread));
            }
        }
    }
}

Example 12 with J9ThreadPointer

use of com.ibm.j9ddr.vm29.pointer.generated.J9ThreadPointer in project openj9 by eclipse.

the class DeadlockUtils method findThreadCycle.

/**
 * @param vmThread
 * @param map
 * @throws CorruptDataException
 */
public static void findThreadCycle(J9ThreadPointer aThread, HashMap<Integer, NativeDeadlockGraphNode> deadlocks, HashMap<J9ObjectPointer, Object> objectMonitorsMap) throws CorruptDataException {
    // Based on JavaCoreDumpWriter::findThreadCycle()
    // Can't stack allocate or (safely) re-purpose an object in Java,
    // so we create a new one on each iteration, this is slightly
    // different from what is done in javadump.cpp
    NativeDeadlockGraphNode node = null;
    NativeDeadlockGraphNode prev = null;
    do {
        // Is there an associated J9VMThread?
        J9VMThreadPointer vmThread = J9ThreadHelper.getVMThread(aThread);
        boolean isJavaThread = (null != vmThread) && vmThread.notNull();
        // Enter waiter (blocked) or notify waiter.
        boolean isJavaWaiter = false;
        if (isJavaThread) {
            // There is, so grab all the J9VMThread related information.
            JavaDeadlockGraphNode javaNode = new JavaDeadlockGraphNode();
            javaNode.javaThread = vmThread;
            J9VMThreadPointer owner = null;
            J9ObjectPointer lockObject = null;
            J9ThreadAbstractMonitorPointer lock = null;
            // Functionally equivalent to getVMThreadStateHelper(...) in thrinfo.c
            lockObject = vmThread.blockingEnterObject();
            if ((null != lockObject) && lockObject.notNull()) {
                // This condition hitting means we are in one of the desired states:
                // J9VMTHREAD_STATE_BLOCKED
                // J9VMTHREAD_STATE_WAITING, J9VMTHREAD_STATE_WAITING_TIMED
                // J9VMTHREAD_STATE_PARKED, J9VMTHREAD_STATE_PARKED_TIMED
                isJavaWaiter = true;
                // The original native relies on getVMThreadStateHelper(...)
                // from thrinfo.c to obtain this information, which is analogous
                // to J9VMThreadPointerUtil.getJ9State(...), but we don't actually
                // need all that information.
                Object current = objectMonitorsMap.get(lockObject);
                if (current instanceof ObjectMonitor) {
                    ObjectMonitor mon = (ObjectMonitor) current;
                    owner = mon.getOwner();
                    lock = mon.getInflatedMonitor();
                } else if (current instanceof J9ThreadMonitorPointer) {
                    // System Monitor
                    J9ThreadMonitorPointer mon = (J9ThreadMonitorPointer) current;
                    J9ThreadPointer sysThread = mon.owner();
                    lock = J9ThreadAbstractMonitorPointer.cast(mon);
                    if (sysThread.notNull()) {
                        owner = J9ThreadHelper.getVMThread(sysThread);
                    }
                }
                if ((null == owner) || owner.isNull() || (owner.equals(vmThread))) {
                    // See JAZZ103 63676: There are cases where even if we know there is no
                    // Java deadlock, we should still check for a system deadlock.
                    // We simply deal with this node as a native one from this point on.
                    isJavaWaiter = false;
                } else {
                    // N.B. In the native there are comparisons with J9VMTHREAD_STATE_*
                    // constants as returned by the helper, but here we don't actually need them.
                    javaNode.javaLock = lock;
                    javaNode.lockObject = lockObject;
                    javaNode.cycle = 0;
                    /* Record current thread and update last node */
                    javaNode.nativeThread = vmThread.osThread();
                    deadlocks.put(javaNode.hashCode(), javaNode);
                    if (null != prev) {
                        prev.next = javaNode;
                    }
                    /* Move around the graph */
                    prev = javaNode;
                    /* Peek ahead to see if we're in a possible cycle */
                    prev.next = deadlocks.get(owner.osThread().hashCode());
                    aThread = owner.osThread();
                }
            }
            // Have to keep going for the case of Java thread blocking on system monitor.
            // We have to write the J9Thread info as well.
            node = javaNode;
        }
        if (false == isJavaThread) {
            node = new NativeDeadlockGraphNode();
        }
        // Now get all of the J9Thread fields (even when we are working with a Java thread).
        node.nativeThread = aThread;
        J9ThreadMonitorPointer nativeLock = aThread.monitor();
        J9ThreadPointer owner = null;
        if ((null == nativeLock) || nativeLock.isNull()) {
            if (false == isJavaThread) {
                return;
            }
        } else {
            node.nativeLock = nativeLock;
            owner = nativeLock.owner();
        }
        // to change the pointers, otherwise we have to set them up.
        if (false == isJavaWaiter) {
            deadlocks.put(node.hashCode(), node);
            if (null != prev) {
                prev.next = node;
            }
            if ((null == owner) || owner.isNull() || (owner.equals(aThread))) {
                return;
            } else {
                /* Move around the graph */
                prev = node;
                /* Peek ahead to see if we're in a possible cycle */
                prev.next = deadlocks.get(owner.hashCode());
                aThread = owner;
            }
        }
    } while (// Quit as soon as possible (first node we've already visited).
    null == prev.next);
// The rest of the cycles will be found by multiple calls to findThreadCycle(...)
}

Example 13 with J9ThreadPointer

use of com.ibm.j9ddr.vm29.pointer.generated.J9ThreadPointer in project openj9 by eclipse.

the class DeadlockDetector method findDeadlocks.

/**
 * @param out
 * @throws DDRInteractiveCommandException
 */
public static void findDeadlocks(PrintStream out) throws DDRInteractiveCommandException {
    // Based on JavaCoreDumpWriter::writeDeadLocks()
    // Modified to work for both J9VMThreads and J9Threads.
    HashMap<Integer, NativeDeadlockGraphNode> map = new HashMap<Integer, NativeDeadlockGraphNode>();
    try {
        J9JavaVMPointer vm = J9RASHelper.getVM(DataType.getJ9RASPointer());
        HashMap<J9ObjectPointer, Object> objectMonitorsMap = DeadlockUtils.readObjectMonitors(vm);
        J9ThreadLibraryPointer lib = vm.mainThread().osThread().library();
        J9PoolPointer pool = lib.thread_pool();
        Pool<J9ThreadPointer> threadPool = Pool.fromJ9Pool(pool, J9ThreadPointer.class);
        SlotIterator<J9ThreadPointer> poolIterator = threadPool.iterator();
        J9ThreadPointer osThreadPtr = null;
        while (poolIterator.hasNext()) {
            osThreadPtr = poolIterator.next();
            DeadlockUtils.findThreadCycle(osThreadPtr, map, objectMonitorsMap);
            // Is there an associated J9VMThread?
            J9VMThreadPointer vmThread = J9ThreadHelper.getVMThread(osThreadPtr);
            if ((null != vmThread) && (vmThread.notNull()) && vmThread.publicFlags().allBitsIn(J9Consts.J9_PUBLIC_FLAGS_HALT_THREAD_INSPECTION)) {
                break;
            }
        }
        // Identifier for each (independent) cycle.
        int cycle = 0;
        Iterator<Map.Entry<Integer, NativeDeadlockGraphNode>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            NativeDeadlockGraphNode node = iterator.next().getValue();
            cycle++;
            while (null != node) {
                if (node.cycle > 0) {
                    // it means we've looped around!
                    if (node.cycle == cycle) {
                        // Output header for each deadlock:
                        out.println("Deadlock Detected !!!");
                        out.println("---------------------");
                        out.println();
                        NativeDeadlockGraphNode head = node;
                        boolean isCycleRoot = true;
                        do {
                            DeadlockUtils.writeDeadlockNode(node, isCycleRoot, objectMonitorsMap, out);
                            node = node.next;
                            isCycleRoot = false;
                        } while (node != head);
                        out.println(node.toString());
                    }
                    // Skip already visited nodes
                    break;
                } else {
                    node.cycle = cycle;
                }
                node = node.next;
            }
        }
    } catch (CorruptDataException e) {
        throw new DDRInteractiveCommandException(e);
    }
}

Example 14 with J9ThreadPointer

use of com.ibm.j9ddr.vm29.pointer.generated.J9ThreadPointer in project openj9 by eclipse.

the class DTFJJavaSystemMonitor method getOwner.

public JavaThread getOwner() throws CorruptDataException {
    JavaThread javaThread = null;
    try {
        J9ThreadPointer owner = monitor.owner();
        if (!owner.isNull()) {
            int vmThreadKey = DTFJContext.getVm().omrVM()._vmThreadKey().intValue() - 1;
            OMR_VMThreadPointer omrVmThread = OMR_VMThreadPointer.cast(owner.tlsEA().at(vmThreadKey));
            if (!omrVmThread.isNull()) {
                javaThread = new DTFJJavaThread(J9VMThreadPointer.cast(omrVmThread._language_vmthread()));
            }
        }
    } catch (Throwable t) {
        throw J9DDRDTFJUtils.handleAsCorruptDataException(DTFJContext.getProcess(), t);
    }
    return javaThread;
}