Java Code Examples for jdk.jfr.internal.test.WhiteBox#setWriteAllObjectSamples()

public static void main(String[] args) throws Throwable {
    WhiteBox.setWriteAllObjectSamples(true);

    try (Recording r = new Recording()) {
        r.enable(EventNames.OldObjectSample).withStackTrace().with("cutoff", "infinity");
        r.start();
        allocateFindMe();
        System.gc();
        r.stop();
        List<RecordedEvent> events = Events.fromRecording(r);
        System.out.println(events);
        if (OldObjects.countMatchingEvents(events, FindMe[].class, null, null, -1, "allocateFindMe") == 0) {
            throw new Exception("Could not find leak with " + FindMe[].class);
        }
    }
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    try (Recording r = new Recording()) {
        r.enable(EventNames.OldObjectSample).withStackTrace().with("cutoff", "infinity");
        r.start();
        allocateFindMe();
        System.gc();
        r.stop();
        List<RecordedEvent> events = Events.fromRecording(r);
        System.out.println(events);
        if (OldObjects.countMatchingEvents(events, FindMe[].class, null, null, -1, "allocateFindMe") == 0) {
            throw new Exception("Could not find leak with " + FindMe[].class);
        }
    }
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    String settingName = EventNames.OldObjectSample + "#" + "cutoff";

    // dump parameter trumps previous setting
    testDump("path-to-gc-roots=true", Collections.singletonMap(settingName, "infinity"), true);
    testDump("path-to-gc-roots=true", Collections.singletonMap(settingName, "0 ns"), true);
    testDump("path-to-gc-roots=true", Collections.emptyMap(), true);

    testDump("path-to-gc-roots=false", Collections.singletonMap(settingName, "infinity"), false);
    testDump("path-to-gc-roots=false", Collections.singletonMap(settingName, "0 ns"), false);
    testDump("path-to-gc-roots=false", Collections.emptyMap(), false);

    testDump("", Collections.singletonMap(settingName, "infinity"), true);
    testDump("", Collections.singletonMap(settingName, "0 ns"), false);
    testDump("", Collections.emptyMap(), false);
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    try (Recording r = new Recording()) {
        r.enable(EventNames.OldObjectSample).withStackTrace().with("cutoff", "infinity");
        r.start();
        leak = createChain();
        List<RecordedEvent> events = Events.fromRecording(r);
        if (OldObjects.countMatchingEvents(events, byte[].class, null, null, -1, "createChain") == 0) {
            throw new Exception("Could not find ChainNode");
        }
        for (RecordedEvent e : events) {
            OldObjects.validateReferenceChainLimit(e, OldObjects.MAX_CHAIN_LENGTH);
        }
    }
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    try (Recording r = new Recording()) {
        r.enable(EventNames.OldObjectSample).withStackTrace().with("cutoff", "infinity");
        r.start();
        allocateFindMe();
        System.gc();
        r.stop();
        List<RecordedEvent> events = Events.fromRecording(r);
        System.out.println(events);
        if (OldObjects.countMatchingEvents(events, FindMe[].class, null, null, -1, "allocateFindMe") == 0) {
            throw new Exception("Could not find leak with " + FindMe[].class);
        }
    }
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    try (Recording recording = new Recording()) {
        recording.enable(EventNames.OldObjectSample).withoutStackTrace().with("cutoff", "infinity");
        recording.start();

        addToTestField();

        recording.stop();

        List<RecordedEvent> events = Events.fromRecording(recording);
        Events.hasEvents(events);
        for (RecordedEvent e : events) {
            if (hasValidField(e)) {
                return;
            }
        }
        System.out.println(events);
        Asserts.fail("Could not find old object with field 'testField'");
    }
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    try (Recording r = new Recording()) {
        r.enable(EventNames.OldObjectSample).withStackTrace().with("cutoff", "infinity");
        r.start();
        allocateFindMe();
        System.gc();
        r.stop();
        List<RecordedEvent> events = Events.fromRecording(r);
        System.out.println(events);
        if (OldObjects.countMatchingEvents(events, FindMe[].class, null, null, -1, "allocateFindMe") == 0) {
            throw new Exception("Could not find leak with " + FindMe[].class);
        }
    }
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    try (Recording recording = new Recording()) {
        recording.enable(EventNames.OldObjectSample).withoutStackTrace().with("cutoff", "infinity");
        recording.start();

        addToTestField();

        recording.stop();

        List<RecordedEvent> events = Events.fromRecording(recording);
        Events.hasEvents(events);
        for (RecordedEvent e : events) {
            if (hasValidField(e)) {
                return;
            }
        }
        System.out.println(events);
        Asserts.fail("Could not find old object with field 'testField'");
    }
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    try (Recording recording = new Recording()) {
        recording.enable(EventNames.OldObjectSample).withoutStackTrace().with("cutoff", "infinity");
        recording.start();
        for(int i = 0; i < 25; i++) {
          leak.add( buildNestedArray(CHAIN_DEPTH));
        }
        recording.stop();
        List<RecordedEvent> events = Events.fromRecording(recording);
        Events.hasEvents(events);
        verifyObjectArray(events);
    }
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);
    long last = 0;
    for (int i = 1; i <= 5; i++) {
        long heapUsage = recordOldObjects(i);
        System.out.println("Recording: " + i + " heapUsage=" + heapUsage);
        if (heapUsage < last) {
            throw new Exception("Unexpect decrease of heap usage");
        }
    }
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    testThreadGroupName();
    testThreadName();
    testClassName();
    testSize();
    testEllipsis();
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    try (Recording r = new Recording()) {
        r.enable(EventNames.OldObjectSample).with("cutoff", "infinity").withStackTrace();
        r.start();

        TestCircularReferrer a = new TestCircularReferrer();
        TestCircularReferrer b = new TestCircularReferrer();
        TestCircularReferrer c = new TestCircularReferrer();
        a.setReference(b);
        b.setReference(c);
        c.setReference(a);
        referenceHolder.add(a);

        TestCircularReferrer selfReflector = new TestCircularReferrer();
        selfReflector.setReference(selfReflector);
        referenceHolder.add(selfReflector);

        r.stop();

        List<RecordedEvent> events = Events.fromRecording(r);
        if (events.isEmpty()) {
            throw new AssertionError("Expected Old Object Sample events!");
        }
    }
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    testThreadGroupName();
    testThreadName();
    testClassName();
    testSize();
    testEllipsis();
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    try (Recording recording = new Recording()) {
        recording.enable(EventNames.OldObjectSample).withStackTrace().with("cutoff", "infinity");
        recording.start();

        addObjectsToShallowArray(leak);
        recording.stop();
        if (OldObjects.countMatchingEvents(recording, "addObjectsToShallowArray", byte[].class, "object", LeakObject.class, -1) < 1) {
            throw new Exception("Could not find shallow leak object");
        }
    }
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    try (Recording r = new Recording()) {
        r.enable(EventNames.OldObjectSample).withStackTrace().with("cutoff", "infinity");
        r.start();
        TestClassLoader testClassLoader = new TestClassLoader();
        for (Class<?> clazz : testClassLoader.loadClasses(OldObjects.MIN_SIZE / 20)) {
            // Allocate array to trigger sampling code path for interpreter / c1
            for (int i = 0; i < 20; i++) {
                Object classArray = Array.newInstance(clazz, 20);
                Array.set(classArray, i, clazz.newInstance());
                classObjects.add(classArray);
            }
        }
        r.stop();
        List<RecordedEvent> events = Events.fromRecording(r);
        Events.hasEvents(events);
        for (RecordedEvent e : events) {
            RecordedObject object = e.getValue("object");
            RecordedClass rc = object.getValue("type");
            if (rc.getName().contains("TestClass")) {
                return;
            }
        }
        Asserts.fail("Could not find class leak");
    }
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    testThreadGroupName();
    testThreadName();
    testClassName();
    testSize();
    testEllipsis();
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    try (Recording r = new Recording()) {
        r.enable(EventNames.OldObjectSample).with("cutoff", "infinity").withStackTrace();
        r.start();

        TestCircularReferrer a = new TestCircularReferrer();
        TestCircularReferrer b = new TestCircularReferrer();
        TestCircularReferrer c = new TestCircularReferrer();
        a.setReference(b);
        b.setReference(c);
        c.setReference(a);
        referenceHolder.add(a);

        TestCircularReferrer selfReflector = new TestCircularReferrer();
        selfReflector.setReference(selfReflector);
        referenceHolder.add(selfReflector);

        r.stop();

        List<RecordedEvent> events = Events.fromRecording(r);
        if (events.isEmpty()) {
            throw new AssertionError("Expected Old Object Sample events!");
        }
    }
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    try (Recording r = new Recording()) {
        r.enable(EventNames.OldObjectSample).withStackTrace().with("cutoff", "infinity");
        r.start();
        listenerLeak();
        r.stop();
        List<RecordedEvent> events = Events.fromRecording(r);
        if (OldObjects.countMatchingEvents(events, Stuff[].class, null, null, -1, "listenerLeak") == 0) {
            throw new Exception("Could not find leak with " + Stuff[].class);
        }
    }
}
 

public static void main(String[] args) throws Exception {
    WhiteBox.setWriteAllObjectSamples(true);

    while(true) {
        try (Recording recording = new Recording()) {
            leak.clear();
            recording.enable(EventNames.OldObjectSample).withStackTrace().with("cutoff", "1 h");
            recording.start();

            BeforeLeakEvent be = new BeforeLeakEvent();
            be.commit();

            // Allocate array to trigger sampling code path for interpreter / c1
            for (int i = 0; i < OldObjects.MIN_SIZE; i++) {
                leak.add(new Leak[0]);
            }

            AfterLeakEvent ae = new AfterLeakEvent();
            ae.commit();

            recording.stop();

            List<RecordedEvent> events = Events.fromRecording(recording);
            Events.hasEvents(events);
            RecordedObject sample = findLeak(events, BeforeLeakEvent.class.getName());
            if (sample != null)  {
                long beforeTime = find(events, BeforeLeakEvent.class.getName()).getValue("startTime");
                long allocationTime = sample.getValue("allocationTime");
                long afterTime = find(events, AfterLeakEvent.class.getName()).getValue("startTime");
                System.out.println("Before time     : " + beforeTime);
                System.out.println("Allocation time : " + allocationTime);
                System.out.println("After time      : " + afterTime);

                if (allocationTime < beforeTime) {
                    throw new Exception("Allocation should not happen this early");
                }
                if (allocationTime > afterTime) {
                    throw new Exception("Allocation should not happen this late");
                }
                return; // sample ok
            }
        }
    }
}
 

public static void main(String[] args) throws Throwable {
    WhiteBox.setWriteAllObjectSamples(true);
    int failedAttempts = 0;
    while (true) {
        try (Recording recording = new Recording()) {
            recording.enable(EventNames.OldObjectSample).withStackTrace();
            recording.enable(EventNames.ClassUnload);
            recording.start();

            // Setup metadata on the Java heap (class, stack trace and thread)
            testClassLoader = new TestClassLoader();
            testClass = testClassLoader.loadClass(TEST_CLASS_NAME);
            allocatorThread = new Thread(TestMetadataRetention::allocateLeak, ALLOCATOR_THREAD_NAME);
            allocatorThread.start();
            allocatorThread.join();

            // Clear out metadata on the heap
            testClassLoader = null;
            testClass = null;
            allocatorThread = null;

            // System.gc() will trigger class unloading if -XX:+ExplicitGCInvokesConcurrent
            // is NOT set. If this flag is set G1 will never unload classes on System.gc()
            // and CMS will not guarantee that all semantically dead classes will be
            // unloaded. As far as the "jfr" key guarantees no VM flags are set from the
            // outside it should be enough with System.gc().
            System.gc();

            // Provoke a chunk rotation, which will flush out ordinary metadata.
            provokeChunkRotation();
            ChunkRotation cr = new ChunkRotation();
            cr.commit();
            recording.stop();

            List<RecordedEvent> events = Events.fromRecording(recording);
            RecordedEvent chunkRotation = findChunkRotationEvent(events);
            try {
                // Sanity check that class was unloaded
                Events.hasEvent(recording, EventNames.ClassUnload);
                validateClassUnloadEvent(events);
                // Validate that metadata for old object event has survived chunk rotation
                Events.hasEvent(recording, EventNames.OldObjectSample);
                validateOldObjectEvent(events, chunkRotation.getStartTime());
            } catch (Throwable t) {
                t.printStackTrace();
                System.err.println("Number of failed attempts " + ++failedAttempts);
                continue;
            }
            break;
        }
    }
}