/*
 * Copyright (c) 2014, 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 rtm;

import java.util.Objects;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

import com.oracle.java.testlibrary.Asserts;
import com.oracle.java.testlibrary.Utils;
import sun.misc.Unsafe;

/**
 * Base class for different transactional execution abortion
 * provokers aimed to force abort due to specified reason.
 */
public abstract class AbortProvoker implements CompilableTest {
    public static final long DEFAULT_ITERATIONS = 10000L;
    /**
     * Inflates monitor associated with object {@code monitor}.
     * Inflation is forced by entering the same monitor from
     * two different threads.
     *
     * @param monitor monitor to be inflated.
     * @return inflated monitor.
     * @throws Exception if something went wrong.
     */
    public static Object inflateMonitor(Object monitor) throws Exception {
        Unsafe unsafe = Utils.getUnsafe();
        CyclicBarrier barrier = new CyclicBarrier(2);

        Runnable inflatingRunnable = () -> {
            unsafe.monitorEnter(monitor);
            try {
                barrier.await();
                barrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                throw new RuntimeException(
                        "Synchronization issue occurred.", e);
            } finally {
                unsafe.monitorExit(monitor);
            }
        };

        Thread t = new Thread(inflatingRunnable);
        t.start();
        // Wait until thread t enters the monitor.
        barrier.await();
        // At this point monitor will be owned by thread t,
        // so our attempt to enter the same monitor will force
        // monitor inflation.
        Asserts.assertFalse(unsafe.tryMonitorEnter(monitor),
                            "Not supposed to enter the monitor first");
        barrier.await();
        t.join();
        return monitor;
    }


    /**
     * Get instance of specified AbortProvoker, inflate associated monitor
     * if needed and then invoke forceAbort method in a loop.
     *
     * Usage:
     * AbortProvoker <AbortType name> [<inflate monitor&gt
     * [<iterations> [ <delay>]]]
     *
     *  Default parameters are:
     *  <ul>
     *  <li>inflate monitor = <b>true</b></li>
     *  <li>iterations = {@code AbortProvoker.DEFAULT_ITERATIONS}</li>
     *  <li>delay = <b>0</b></li>
     *  </ul>
     */
    public static void main(String args[]) throws Throwable {
        Asserts.assertGT(args.length, 0, "At least one argument is required.");

        AbortType abortType = AbortType.lookup(Integer.valueOf(args[0]));
        boolean monitorShouldBeInflated = true;
        long iterations = AbortProvoker.DEFAULT_ITERATIONS;

        if (args.length > 1) {
            monitorShouldBeInflated = Boolean.valueOf(args[1]);

            if (args.length > 2) {
                iterations = Long.valueOf(args[2]);

                if (args.length > 3) {
                    Thread.sleep(Integer.valueOf(args[3]));
                }
            }
        }

        AbortProvoker provoker = abortType.provoker();

        if (monitorShouldBeInflated) {
            provoker.inflateMonitor();
        }

        for (long i = 0; i < iterations; i++) {
            provoker.forceAbort();
        }
    }

    protected final Object monitor;

    protected AbortProvoker() {
        this(new Object());
    }

    protected AbortProvoker(Object monitor) {
        this.monitor = Objects.requireNonNull(monitor);
    }

    /**
     * Inflates monitor used by this AbortProvoker instance.
     * @throws Exception
     */
    public void inflateMonitor() throws Exception {
        AbortProvoker.inflateMonitor(monitor);
    }

    /**
     * Forces transactional execution abortion.
     */
    public abstract void forceAbort();

    /**
     * Returns names of all methods that have to be compiled
     * in order to successfully force transactional execution
     * abortion.
     *
     * @return array with methods' names that have to be compiled.
     */
    @Override
    public String[] getMethodsToCompileNames() {
        return new String[] { getMethodWithLockName() };
    }

    /**
     * Returns name of the method that will contain monitor whose locking
     * will be elided using transactional execution.
     *
     * @return name of the method that will contain elided lock.
     */
    @Override
    public String getMethodWithLockName() {
        return this.getClass().getName() + "::forceAbort";
    }
}