* @build compiler.runtime.Test8010927

 * @run driver ClassFileInstaller sun.hotspot.WhiteBox

 *                                sun.hotspot.WhiteBox$WhiteBoxPermission

 * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+IgnoreUnrecognizedVMOptions

 *                   -XX:+WhiteBoxAPI -Xbootclasspath/a:. -Xmx64m -XX:NewSize=20971520

 *                   -XX:MaxNewSize=32m -XX:-UseTLAB -XX:-UseAdaptiveSizePolicy

 *                   compiler.runtime.Test8010927

package compiler.runtime;

import jdk.internal.misc.Unsafe;

    private static final Unsafe U;

    static {

        try {

            Field unsafe = Unsafe.class.getDeclaredField("theUnsafe");

            unsafe.setAccessible(true);

            U = (Unsafe) unsafe.get(null);

        } catch (Exception e) {

            throw new Error(e);

        }

    public static Object[] o;

    public static final boolean debug = Boolean.getBoolean("debug");

    // 2 different obect arrays but same element types

    static Test8010927[] masterA;

    static Object[] masterB;

    static final Test8010927 elem = new Test8010927();

    static final WhiteBox wb = WhiteBox.getWhiteBox();

    static final int obj_header_size = U.ARRAY_OBJECT_BASE_OFFSET;

    static final int heap_oop_size = wb.getHeapOopSize();

    static final int card_size = 512;

    static final int one_card = (card_size - obj_header_size) / heap_oop_size;

    static final int surv_size = 2112 * 1024;

    // The size is big to not fit into survive space.

    static final Object[] cache = new Object[(surv_size / card_size)];

    public static void main(String[] args) {

        masterA = new Test8010927[one_card];

        masterB = new Object[one_card];

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

            masterA[i] = elem;

            masterB[i] = elem;

        // Move cache[] to the old gen.

        long low_limit = wb.getObjectAddress(cache);

        System.gc();

        // Move 'cache' to oldgen.

        long upper_limit = wb.getObjectAddress(cache);

        if ((low_limit - upper_limit) > 0) { // substaction works with unsigned values

            // OldGen is placed before youngger for ParallelOldGC.

            upper_limit = low_limit + 21000000l; // +20971520

        }

        // Each A[one_card] size is 512 bytes,

        // it will take about 40000 allocations to trigger GC.

        // cache[] has 8192 elements so GC should happen

        // each 5th iteration.

        for (long l = 0; l < 20; l++) {

            fill_heap();

            if (debug) {

                System.out.println("test oop_disjoint_arraycopy");

            }

            testA_arraycopy();

            if (debug) {

                System.out.println("test checkcast_arraycopy");

            }

            testB_arraycopy();

            // Execute arraycopy to the topmost array in young gen

            if (debug) {

                int top_index = get_top_address(low_limit, upper_limit);

                if (top_index >= 0) {

                    long addr = wb.getObjectAddress(cache[top_index]);

                    System.out.println("top_addr: 0x" + Long.toHexString(addr) + ", 0x" + Long.toHexString(addr + 512));

                }

            }

        }

    static void fill_heap() {

        for (int i = 0; i < cache.length; ++i) {

            o = new Test8010927[one_card];

            System.arraycopy(masterA, 0, o, 0, masterA.length);

            cache[i] = o;

        }

        for (long j = 0; j < 256; ++j) {

            o = new Long[10000]; // to trigger GC

        }

    static void testA_arraycopy() {

        for (int i = 0; i < cache.length; ++i) {

            System.arraycopy(masterA, 0, cache[i], 0, masterA.length);

        }

    static void testB_arraycopy() {

        for (int i = 0; i < cache.length; ++i) {

            System.arraycopy(masterB, 0, cache[i], 0, masterB.length);

        }

    static int get_top_address(long min, long max) {

        int index = -1;

        long addr = min;

        for (int i = 0; i < cache.length; ++i) {

            long test = wb.getObjectAddress(cache[i]);

            if (((test - addr) > 0) && ((max - test) > 0)) { // substaction works with unsigned values

                addr = test;

                index = i;

            }

        }

        return index;