/*
 * Copyright (c) 2015, 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
 * @summary Tests if reachabilityFence is working
 *
 * @run main/othervm/timeout=600 -Xint                   -Dpremature=false ReachabilityFence
 * @run main/othervm/timeout=600 -XX:TieredStopAtLevel=1 -Dpremature=true  ReachabilityFence
 * @run main/othervm/timeout=600 -XX:TieredStopAtLevel=2 -Dpremature=true  ReachabilityFence
 * @run main/othervm/timeout=600 -XX:TieredStopAtLevel=3 -Dpremature=true  ReachabilityFence
 * @run main/othervm/timeout=600 -XX:TieredStopAtLevel=4 -Dpremature=true  ReachabilityFence
 */

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;


public class ReachabilityFence2 {

    /*
     * Implementation notes:
     *
     * This test has positive and negative parts.
     *
     * Negative test is "nonFenced", and it tests that absent of reachabilityFence, the object can
     * be prematurely finalized -- this validates the test itself. Not every VM mode is expected to
     * prematurely finalize the objects, and -Dpremature option communicates that to test. If a VM mode
     * passes the negative test, then our understanding of what could happen is correct, and we can
     * go forward.
     *
     * Positive test is "fenced", and it checks that given the reachabilityFence at the end of the block,
     * the object cannot be finalized. There is no sense running a positive test when premature finalization
     * is not expected. It is a job for negative test to verify that invariant.
     *
     * The test methods should be appropriately compiled, therefore we do several iterations.
     */

    static final long NEGATIVE_TIMEOUT = TimeUnit.SECONDS.toNanos(5);
    static final long WARMUP_TIMEOUT = TimeUnit.MILLISECONDS.toNanos(200);

    static final boolean PREMATURE_FINALIZATION = Boolean.getBoolean("premature");

    public static void main(String... args) {

        long t0 = System.nanoTime();
        boolean finalized = nonFenced(NEGATIVE_TIMEOUT);
        long positiveTimeout = (System.nanoTime() - t0) * 3;

        if (PREMATURE_FINALIZATION && !finalized) {
            throw new IllegalStateException("The object had never been finalized before timeout reached.");
        }

        if (!PREMATURE_FINALIZATION && finalized) {
            throw new IllegalStateException("The object had been finalized without a fence, even though we don't expect it.");
        }

        if (PREMATURE_FINALIZATION && fenced(positiveTimeout)) {
            throw new IllegalStateException("The object had been prematurely finalized.");
        }
    }

    static boolean nonFenced(long timeout) {
        long t0 = System.nanoTime();
        long dur = 0;
        boolean fin;
        while (!(fin = nonFencedTry(dur)) && dur < timeout) {
            dur = System.nanoTime() - t0;
        }
        return fin;
    }

    static boolean nonFencedTry(long dur) {
        MyFinalizeable o = new MyFinalizeable();
        AtomicBoolean finalized = o.finalized;
        doGc(dur);
        boolean fin = finalized.get();
        //inlineableNoOp(o);
        return fin;
    }

    static boolean fenced(long timeout) {
        long t0 = System.nanoTime();
        long dur = 0;
        boolean fin;
        while (!(fin = fencedTry(dur)) && dur < timeout) {
            dur = System.nanoTime() - t0;
        }
        return fin;
    }

    static boolean fencedTry(long dur) {
        MyFinalizeable o = new MyFinalizeable();
        AtomicBoolean finalized = o.finalized;
        doGc(dur);
        boolean fin = finalized.get();
        inlineableNoOp(o);
        return fin;
    }

    static void doGc(long dur) {
        if (dur > WARMUP_TIMEOUT) {
            System.gc();
            try { Thread.sleep(200); } catch (InterruptedException e) { }
        }
    }

    static void inlineableNoOp(Object o) {
    }

    static void reachabilityFence(Object o) {
        synchronized (o) {
            o.hashCode();
        }
    }

    static final class MyFinalizeable {
        final AtomicBoolean finalized = new AtomicBoolean();

        MyFinalizeable() {}

        @Override
        protected void finalize() throws Throwable {
            super.finalize();
            finalized.set(true);
        }
    }
}