test/hotspot/jtreg/gc/g1/humongousObjects/objectGraphTest/GC.java

/*
 * Copyright (c) 2016, 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.
 */

package gc.g1.humongousObjects.objectGraphTest;

import gc.testlibrary.Helpers;
import jdk.test.lib.Asserts;
import sun.hotspot.WhiteBox;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

/**
 * Provides methods to initiate GC of requested type and
 * checks for states of humongous and non-humongous soft/weak externally
 * referenced objects after GCs
 */
public enum GC {
    CMC {
        @Override
        public Runnable get() {
            return () -> {
                Helpers.waitTillCMCFinished(WHITE_BOX, 0);
                WHITE_BOX.g1StartConcMarkCycle();
                Helpers.waitTillCMCFinished(WHITE_BOX, 0);
            };
        }

        public Consumer<ReferenceInfo<Object[]>> getChecker() {
            return getCheckerImpl(false, false, true, false);
        }

        @Override
        public List<String> shouldContain() {
            return Arrays.asList(GCTokens.WB_INITIATED_CMC);
        }

        @Override
        public List<String> shouldNotContain() {
            return Arrays.asList(GCTokens.WB_INITIATED_YOUNG_GC, GCTokens.WB_INITIATED_MIXED_GC,
                    GCTokens.FULL_GC, GCTokens.YOUNG_GC);
        }
    },

    CMC_NO_SURV_ROOTS {
        @Override
        public Runnable get() {
            return () -> {
                WHITE_BOX.youngGC();
                Helpers.waitTillCMCFinished(WHITE_BOX, 0);
                WHITE_BOX.youngGC();
                Helpers.waitTillCMCFinished(WHITE_BOX, 0);

                WHITE_BOX.g1StartConcMarkCycle();
                Helpers.waitTillCMCFinished(WHITE_BOX, 0);
            };
        }

        public Consumer<ReferenceInfo<Object[]>> getChecker() {
            return getCheckerImpl(true, false, true, false);
        }

        @Override
        public List<String> shouldContain() {
            return Arrays.asList(GCTokens.WB_INITIATED_CMC);
        }

        @Override
        public List<String> shouldNotContain() {
            return Arrays.asList(GCTokens.WB_INITIATED_MIXED_GC,
                    GCTokens.FULL_GC, GCTokens.YOUNG_GC);
        }
    },

    YOUNG_GC {
        @Override
        public Runnable get() {
            return WHITE_BOX::youngGC;
        }

        public Consumer<ReferenceInfo<Object[]>> getChecker() {
            return getCheckerImpl(false, false, true, false);
        }

        @Override
        public List<String> shouldContain() {
            return Arrays.asList(GCTokens.WB_INITIATED_YOUNG_GC);
        }

        @Override
        public List<String> shouldNotContain() {
            return Arrays.asList(GCTokens.WB_INITIATED_MIXED_GC, GCTokens.FULL_GC, GCTokens.WB_INITIATED_CMC,
                    GCTokens.CMC, GCTokens.YOUNG_GC);
        }
    },

    FULL_GC {
        @Override
        public Runnable get() {
            return System::gc;
        }

        public Consumer<ReferenceInfo<Object[]>> getChecker() {
            return getCheckerImpl(true, false, true, false);
        }

        @Override
        public List<String> shouldContain() {
            return Arrays.asList(GCTokens.FULL_GC);
        }

        @Override
        public List<String> shouldNotContain() {
            return Arrays.asList(GCTokens.WB_INITIATED_YOUNG_GC, GCTokens.WB_INITIATED_MIXED_GC,
                    GCTokens.WB_INITIATED_CMC, GCTokens.CMC, GCTokens.YOUNG_GC);
        }
    },

    MIXED_GC {
        @Override
        public Runnable get() {
            return () -> {
                WHITE_BOX.youngGC();
                Helpers.waitTillCMCFinished(WHITE_BOX, 0);
                WHITE_BOX.youngGC();
                Helpers.waitTillCMCFinished(WHITE_BOX, 0);

                WHITE_BOX.g1StartConcMarkCycle();
                Helpers.waitTillCMCFinished(WHITE_BOX, 0);

                WHITE_BOX.youngGC();
                Helpers.waitTillCMCFinished(WHITE_BOX, 0);
                // Provoking Mixed GC
                WHITE_BOX.youngGC();// second evacuation pause will be mixed
                Helpers.waitTillCMCFinished(WHITE_BOX, 0);
            };
        }

        public Consumer<ReferenceInfo<Object[]>> getChecker() {
            return getCheckerImpl(true, false, true, false);
        }

        @Override
        public List<String> shouldContain() {
            return Arrays.asList(GCTokens.WB_INITIATED_CMC);
        }

        @Override
        public List<String> shouldNotContain() {
            return Arrays.asList(GCTokens.YOUNG_GC);
        }
    },

    FULL_GC_MEMORY_PRESSURE {
        @Override
        public Runnable get() {
            return WHITE_BOX::fullGC;
        }

        public Consumer<ReferenceInfo<Object[]>> getChecker() {
            return getCheckerImpl(true, true, true, true);
        }

        @Override
        public List<String> shouldContain() {
            return Arrays.asList(GCTokens.FULL_GC_MEMORY_PRESSURE);
        }

        @Override
        public List<String> shouldNotContain() {
            return Arrays.asList(GCTokens.WB_INITIATED_YOUNG_GC, GCTokens.WB_INITIATED_MIXED_GC,
                    GCTokens.WB_INITIATED_CMC, GCTokens.CMC, GCTokens.YOUNG_GC, GCTokens.FULL_GC);
        }
    };

    protected String getErrorMessage(ReferenceInfo<Object[]> ref, boolean expectedNull, String gcType) {
        return String.format("Externally effectively %s referenced %shumongous object was%s deleted after %s",
                (ref.softlyReachable ? "soft" : "weak"), (ref.effectiveHumongous ? "" : "non-"),
                (expectedNull ? " not" : ""), gcType);
    }

    protected Consumer<ReferenceInfo<Object[]>> getCaseCheck(boolean expectedNull) {
        return expectedNull
                ? r -> Asserts.assertNull(r.reference.get(), getErrorMessage(r, true, name()))
                : r -> Asserts.assertNotNull(r.reference.get(), getErrorMessage(r, false, name()));
    }

    protected Consumer<ReferenceInfo<Object[]>> getCheckerImpl(boolean weakH, boolean softH,
                                                               boolean weakS, boolean softS) {
        return new Checker(getCaseCheck(weakH), getCaseCheck(softH), getCaseCheck(weakS), getCaseCheck(softS));
    }

    protected String getGcLogName(String prefix) {
        return prefix + "_" + name() + ".gc.log";
    }

    private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();

    /**
     * @return method to initiate GC
     */
    public abstract Runnable get();

    /**
     * @return checker for objects' states after GC
     */
    public abstract Consumer<ReferenceInfo<Object[]>> getChecker();

    /**
     * @return list of tokens that should be contained in gc log after gc of specified type
     */
    public abstract List<String> shouldContain();

    /**
     * @return list of tokens that should not be contained in gc log after gc of specified type
     */
    public abstract List<String> shouldNotContain();


    /**
     * Checks object' state after gc
     * Contains 4 Consumers which are called depending on humongous/non-humongous and
     * external weak/soft referenced objects
     */
    private static class Checker implements Consumer<ReferenceInfo<Object[]>> {
        // 4 consumers with checks for (humongous /simple objects)*(weak/soft referenced)
        final Consumer<ReferenceInfo<Object[]>> weakHumongousCheck;
        final Consumer<ReferenceInfo<Object[]>> softHumongousCheck;
        final Consumer<ReferenceInfo<Object[]>> weakSimpleCheck;
        final Consumer<ReferenceInfo<Object[]>> softSimpleCheck;

        public Checker(Consumer<ReferenceInfo<Object[]>> weakHumongousCheck,
                       Consumer<ReferenceInfo<Object[]>> softHumongousCheck,
                       Consumer<ReferenceInfo<Object[]>> weakSimpleCheck,
                       Consumer<ReferenceInfo<Object[]>> softSimpleCheck) {
            this.weakHumongousCheck = weakHumongousCheck;
            this.softHumongousCheck = softHumongousCheck;
            this.weakSimpleCheck = weakSimpleCheck;
            this.softSimpleCheck = softSimpleCheck;
        }

        public void accept(ReferenceInfo<Object[]> ref) {

            System.out.println("reference.get() returned " + ref.reference.get());
            if (ref.effectiveHumongous && ref.softlyReachable) {
                System.out.println("soft and humongous");
                softHumongousCheck.accept(ref);
            }

            if (ref.effectiveHumongous && !ref.softlyReachable) {
                System.out.println("weak and humongous");
                weakHumongousCheck.accept(ref);

            }

            if (!ref.effectiveHumongous && ref.softlyReachable) {
                System.out.println("soft and non-humongous");
                softSimpleCheck.accept(ref);
            }

            if (!ref.effectiveHumongous && !ref.softlyReachable) {
                System.out.println("weak and non-humongous");
                weakSimpleCheck.accept(ref);
            }
        }
    }

}