/*

 * 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

 * @bug     4959889 6992968

 * @summary Basic unit test of memory management testing:

 *          1) setCollectionUsageThreshold() and getCollectionUsageThreshold()

 *          2) test notification emitted for two different memory pools.

 *

 * @author  Mandy Chung

 *

 * @library /lib/testlibrary/

 * @build jdk.testlibrary.* CollectionUsageThreshold MemoryUtil RunUtil

 * @requires vm.opt.ExplicitGCInvokesConcurrent == "false" | vm.opt.ExplicitGCInvokesConcurrent == "null"

 * @run main/timeout=300 CollectionUsageThreshold

 */

import java.util.*;

import java.util.concurrent.*;

import java.util.concurrent.atomic.AtomicInteger;

import javax.management.*;

import javax.management.openmbean.CompositeData;

import java.lang.management.*;

import static java.lang.management.MemoryNotificationInfo.*;;

import static java.lang.management.ManagementFactory.*;

public class CollectionUsageThreshold {

    private static final MemoryMXBean mm = getMemoryMXBean();

    private static final Map<String, PoolRecord> result = new HashMap<>();

    private static boolean trace = false;

    private static volatile int numMemoryPools = 1;

    private static final int NUM_GCS = 3;

    private static final int THRESHOLD = 10;

    private static volatile int numGCs = 0;

    // semaphore to signal the arrival of a low memory notification

    private static final Semaphore signals = new Semaphore(0);

    // barrier for the main thread to wait until the checker thread

    // finishes checking the low memory notification result

    private static final CyclicBarrier barrier = new CyclicBarrier(2);

    /**

     * Run the test multiple times with different GC versions.

     * First with default command line specified by the framework.

     * Then with GC versions specified by the test.

     */

    public static void main(String a[]) throws Throwable {

        final String main = "CollectionUsageThreshold$TestMain";

        RunUtil.runTestKeepGcOpts(main);

        RunUtil.runTestClearGcOpts(main, "-XX:+UseSerialGC");

        RunUtil.runTestClearGcOpts(main, "-XX:+UseParallelGC");

        RunUtil.runTestClearGcOpts(main, "-XX:+UseG1GC");

        RunUtil.runTestClearGcOpts(main, "-XX:+UseConcMarkSweepGC");

    }

    static class PoolRecord {

        private final MemoryPoolMXBean pool;

        private final AtomicInteger listenerInvoked = new AtomicInteger(0);

        private volatile long notifCount = 0;

        PoolRecord(MemoryPoolMXBean p) {

            this.pool = p;

        }

        int getListenerInvokedCount() {

            return listenerInvoked.get();

        }

        long getNotifCount() {

            return notifCount;

        }

        MemoryPoolMXBean getPool() {

            return pool;

        }

        void addNotification(MemoryNotificationInfo minfo) {

            listenerInvoked.incrementAndGet();

            notifCount = minfo.getCount();

        }

    }

    static class SensorListener implements NotificationListener {

        @Override

        public void handleNotification(Notification notif, Object handback) {

            String type = notif.getType();

            if (MEMORY_THRESHOLD_EXCEEDED.equals(type) ||

                MEMORY_COLLECTION_THRESHOLD_EXCEEDED.equals(type)) {

                MemoryNotificationInfo minfo = MemoryNotificationInfo.

                    from((CompositeData) notif.getUserData());

                MemoryUtil.printMemoryNotificationInfo(minfo, type);

                PoolRecord pr = (PoolRecord) result.get(minfo.getPoolName());

                if (pr == null) {

                    throw new RuntimeException("Pool " + minfo.getPoolName() +

                        " is not selected");

                }

                if (!MEMORY_COLLECTION_THRESHOLD_EXCEEDED.equals(type)) {

                    throw new RuntimeException("Pool " + minfo.getPoolName() +

                        " got unexpected notification type: " +

                        type);

                }

                pr.addNotification(minfo);

                System.out.println("notifying the checker thread to check result");

                signals.release();

            }

        }

    }

    private static class TestMain {

        public static void main(String args[]) throws Exception {

            if (args.length > 0 && args[0].equals("trace")) {

                trace = true;

            }

            List<MemoryPoolMXBean> pools = getMemoryPoolMXBeans();

            List<MemoryManagerMXBean> managers = getMemoryManagerMXBeans();

            if (trace) {

                MemoryUtil.printMemoryPools(pools);

                MemoryUtil.printMemoryManagers(managers);

            }

            // Find the Old generation which supports low memory detection

            for (MemoryPoolMXBean p : pools) {

                if (p.isUsageThresholdSupported() && p.isCollectionUsageThresholdSupported()) {

                    if (p.getName().toLowerCase().contains("perm")) {

                        // if we have a "perm gen" pool increase the number of expected

                        // memory pools by one.

                        numMemoryPools++;

                    }

                    PoolRecord pr = new PoolRecord(p);

                    result.put(p.getName(), pr);

                    if (result.size() == numMemoryPools) {

                        break;

                    }

                }

            }

            if (result.size() != numMemoryPools) {

                throw new RuntimeException("Unexpected number of selected pools");

            }

            try {

                // This test creates a checker thread responsible for checking

                // the low memory notifications.  It blocks until a permit

                // from the signals semaphore is available.

                Checker checker = new Checker("Checker thread");

                checker.setDaemon(true);

                checker.start();

                for (PoolRecord pr : result.values()) {

                    pr.getPool().setCollectionUsageThreshold(THRESHOLD);

                    System.out.println("Collection usage threshold of " +

                        pr.getPool().getName() + " set to " + THRESHOLD);

                }

                SensorListener listener = new SensorListener();

                NotificationEmitter emitter = (NotificationEmitter) mm;

                emitter.addNotificationListener(listener, null, null);

                // The main thread invokes GC to trigger the VM to perform

                // low memory detection and then waits until the checker thread

                // finishes its work to check for a low-memory notification.

                //

                // At GC time, VM will issue low-memory notification and invoke

                // the listener which will release a permit to the signals semaphore.

                // When the checker thread acquires the permit and finishes

                // checking the low-memory notification, it will also call

                // barrier.await() to signal the main thread to resume its work.

                for (int i = 0; i < NUM_GCS; i++) {

                    invokeGC();

                    barrier.await();

                }

            } finally {

                // restore the default

                for (PoolRecord pr : result.values()) {

                    pr.getPool().setCollectionUsageThreshold(0);

                }

            }

            System.out.println(RunUtil.successMessage);

        }

        private static void invokeGC() {

            System.out.println("Calling System.gc()");

            numGCs++;

            mm.gc();

            if (trace) {

                for (PoolRecord pr : result.values()) {

                    System.out.println("Usage after GC for: " + pr.getPool().getName());

                    MemoryUtil.printMemoryUsage(pr.getPool().getUsage());

                }

            }

        }

    }

    static class Checker extends Thread {

        Checker(String name) {

            super(name);

        };

        @Override

        public void run() {

            while (true) {

                try {

                    signals.acquire(numMemoryPools);

                    checkResult();

                } catch (InterruptedException | BrokenBarrierException e) {

                    throw new RuntimeException(e);

                }

            }

        }

        private void checkResult() throws InterruptedException, BrokenBarrierException {

            for (PoolRecord pr : result.values()) {

                if (pr.getListenerInvokedCount() != numGCs) {

                    fail("Listeners invoked count = " +

                         pr.getListenerInvokedCount() + " expected to be " +

                         numGCs);

                }

                if (pr.getNotifCount() != numGCs) {

                    fail("Notif Count = " +

                         pr.getNotifCount() + " expected to be " +

                         numGCs);

                }

                long count = pr.getPool().getCollectionUsageThresholdCount();

                if (count != numGCs) {

                    fail("CollectionUsageThresholdCount = " +

                         count + " expected to be " + numGCs);

                }

                if (!pr.getPool().isCollectionUsageThresholdExceeded()) {

                    fail("isCollectionUsageThresholdExceeded" +

                         " expected to be true");

                }

            }

            // wait until the main thread is waiting for notification

            barrier.await();

            System.out.println("notifying main thread to continue - result checking finished");

        }

        private void fail(String msg) {

            // reset the barrier to cause BrokenBarrierException to avoid hanging

            barrier.reset();

            throw new RuntimeException(msg);

        }

    }

}