jdk-24/test/hotspot/jtreg/vmTestbase/gc/memory/Nio/Nio.java

/*
 * Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * @test
 * @modules java.base/jdk.internal.misc
 * @key stress gc
 *
 * @summary converted from VM Testbase gc/memory/Nio.
 * VM Testbase keywords: [gc, stress, stressopt, monitoring]
 *
 * @library /vmTestbase
 *          /test/lib
 * @run driver jdk.test.lib.FileInstaller . .
 * @run main/othervm -XX:MaxDirectMemorySize=50M gc.memory.Nio.Nio
 */

package gc.memory.Nio;

import java.lang.management.ManagementFactory;
import java.nio.ByteBuffer;
import jdk.internal.misc.VM;
import com.sun.management.HotSpotDiagnosticMXBean;
import java.io.File;
import java.io.IOException;

/**
 * Test that uses java.nio.ByteBuffer to allocate native memory.
 * The test allocates all the memory available and checks that
 * further attempts to allocate more more will fail.
 * Test also checks that allocating native memory doesn't affect heap.
 * Test also cheks that GC can find unused native memory.
 *
 * @summary Checks that nio.ByteBuffer allocates native memory and doesn't affect heap.
 * @run main/othervm -XX:MaxDirectMemorySize=50M gc.memory.Nio.Nio
 */
public class Nio {

    static final int MAX_SIZE = (int)VM.maxDirectMemory();

    public static void main(String[] args) {
        System.exit(new Nio().run() + 95 /*STATUS_BASE*/);
    }

    public Nio() {
    }

    public int run() {
        // Step0: init
        gc();
        long usedHeap_0 = getUsedHeap();
        long usedNonHeap_0 = getUsedNonHeap();

        // Step1: allocate the all available direct memory
        //        no OOME, no heap memory should be used
        System.out.println("Allocating all the direct memory: " + MAX_SIZE);
        ByteBuffer bb;
        try {
            bb = ByteBuffer.allocateDirect((int)MAX_SIZE);
            System.out.println("... success");
        } catch (OutOfMemoryError oom) {
            throw new Fault("Unexpected OOME during the first allocation " + oom);
        }
        long usedHeap_1 = getUsedHeap();
        long usedNonHeap_1 = getUsedNonHeap();
        checkHeapIsNotAffected(usedHeap_0, usedHeap_1, usedNonHeap_0, usedNonHeap_1);
        // Step2: invoke GC, it shouldn't help.
        System.out.println("Doing gc");
        gc();

        // Step3: allocate 1 byte in the direct memory
        //        OOM is expected
        try {
            System.out.println("Allocating 1 byte");
            ByteBuffer.allocateDirect(1);
            throw new Fault("No OOM, but we already allocated all the memory");
        } catch (OutOfMemoryError oom) {
            System.out.println("Expected OOM " + oom);
        }

        // Step4: read and write into allocated memory
        double d0 = -3.1415;
        float  f0 = 41234.6f;
        bb.putDouble(MAX_SIZE/2, d0);
        bb.putFloat(MAX_SIZE - 17, f0);
        double d1 = bb.getDouble(MAX_SIZE/2);
        float f1 = bb.getFloat(MAX_SIZE - 17);
        System.out.println("put: " + d0 + ", " + f0);
        System.out.println("got: " + d1 + ", " + f1);
        if (d0 != d1 || f0 != f1) {
            throw new Fault("read/write to buffer check failed");
        }

        // Step5:
        //  clean the buffer, use gc, try to allocate again
        //  no OOM is expected
        bb = null;
        gc();
        try {
            System.out.println("Allocating 10 bytes");
            ByteBuffer.allocateDirect(10);
        } catch (OutOfMemoryError oom) {
            throw new Fault("Nop, OOM is unexpected again: " + oom);
        }


        System.out.println("The long quest has done! Congratulations");

        return 0;
    }


    public static void gc() {
        System.gc();
        try {
            Thread.currentThread().sleep(200);
        } catch (Exception ignore) {
        }
    }

    /**
     * @return the size of used heap
     */
    public static long getUsedHeap() {
         return ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
    }

    /**
     * @return the size of used non heap
     */
    public static long getUsedNonHeap() {
         return ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage().getUsed();
    }

    /**
     * Check that heap and non-heap memory have NOT changed significantly.
     * Throws a Fault if check failed.
     *
     * @param h_before  used heap before
     * @param h_after   used heap after
     * @param nh_before used non heap before
     * @param nh_after  used non heap after
     */
    void checkHeapIsNotAffected(long h_before, long h_after, long nh_before, long nh_after) {

        if (h_after - h_before > MAX_SIZE * 0.75) {
            System.err.println("Used heap before: " + h_before);
            System.err.println("Used heap after : " + h_after);
            dumpHeap();
            String failed = "Allocating direct memory should not eat the heap!"
                    + " Heap dumped to heapDump.hprof file.";
            throw new Fault(failed);
        }
        if (nh_after - nh_before > MAX_SIZE * 0.75) {
            System.err.println("Used heap before: " + nh_before);
            System.err.println("Used heap after : " + nh_after);
            dumpHeap();
            throw new Fault("Allocating direct memory should not eat non the heap!");
        }
    }

    /**
     * Try to make heap dump
     */
    void dumpHeap() {
        HotSpotDiagnosticMXBean mxBean = ManagementFactory
                .getPlatformMXBean(HotSpotDiagnosticMXBean.class);
        try {
            System.out.println("Try to dump heap to heapDump.hprof file..");
            mxBean.dumpHeap("heapDump.hprof", false);
            System.out.println("Done");
        } catch (IOException e) {
            System.out.println("Failed to dump heap");
            e.printStackTrace();
        }
    }

    /**
     * RuntimeException signaling a test failure.
     */
    public static class Fault extends RuntimeException {
        public Fault(String message) {
            super(message);
        }
    }

}