gcl001.java

/*
 * Copyright (c) 2007, 2020, 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
 * @key stress randomness
 *
 * @summary converted from VM testbase nsk/stress/jni/gclocker/gcl001.
 * VM testbase keywords: [stress, quick, feature_283, nonconcurrent]
 * VM testbase readme:
 * DESCRIPTION
 *     Check compatibility of GC Locker improvements with JNI CS
 * Two types of concurrent threads are present:
 * A) Create N 'JNI CS' threads. Each of them will:
 *    1. Create primitive array and string with random data
 *    2. Pass it to native method
 *    3. Sort/Hash data in JNI CS mixing string and array critical sections
 *    4. Return from native
 *    5. Check data to be processed correctly
 * B) Create M ' Garbage producer/memory allocation' threads. Each of them will:
 *    1. Allocate memory blocks and make them garbage.
 *    2. Check for OOM errors.
 *
 * @library /vmTestbase
 *          /test/lib
 * @run main/othervm/native/timeout=480
 *      -XX:-UseGCOverheadLimit
 *      nsk.stress.jni.gclocker.gcl001
 *      -stressThreadsFactor 8
 */

package nsk.stress.jni.gclocker;

import nsk.share.gc.GC;
import nsk.share.gc.ThreadedGCTest;
import nsk.share.gc.gp.array.BooleanArrayProducer;
import nsk.share.gc.gp.array.ByteArrayProducer;
import nsk.share.gc.gp.array.CharArrayProducer;
import nsk.share.gc.gp.array.DoubleArrayProducer;
import nsk.share.gc.gp.array.FloatArrayProducer;
import nsk.share.gc.gp.array.IntArrayProducer;
import nsk.share.gc.gp.array.LongArrayProducer;
import nsk.share.gc.gp.array.ShortArrayProducer;
import nsk.share.test.ExecutionController;
import nsk.share.test.LocalRandom;

public class gcl001 extends ThreadedGCTest {

    static {
        System.loadLibrary("gcl001");
    }

    int maxBlockSize;

    public static void main(String[] args) {
        GC.runTest(new gcl001(), args);
    }

    @Override
    public void run() {
        // each thread have only one block at the time
        // so we should occupy less then 60% of heap with live objects
        long maxSize = runParams.getTestMemory() / runParams.getNumberOfThreads();
        if (maxSize > Integer.MAX_VALUE - 1) {
            maxSize = Integer.MAX_VALUE - 1;
        }
        maxBlockSize = (int) maxSize;
        log.info("Maximium block size = " + maxBlockSize);
        super.run();
    }

    @Override
    protected Runnable createRunnable(int i) {
        if (i < runParams.getNumberOfThreads() / 2) {
            return CreateJNIWorker(i, maxBlockSize);
        } else {
            return new GarbageProducer(maxBlockSize);
        }
    }

    public Runnable CreateJNIWorker(int number, int size) {
        JNIAbstractWorker worker = null;
        switch (number % 8) {
            case 0:
                worker = new JNIBooleanWorker(size);
                break;
            case 1:
                worker = new JNIByteWorker(size);
                break;
            case 2:
                worker = new JNICharWorker(size);
                break;
            case 3:
                worker = new JNIShortWorker(size);
                break;
            case 4:
                worker = new JNIIntWorker(size);
                break;
            case 5:
                worker = new JNILongWorker(size);
                break;
            case 6:
                worker = new JNIFloatWorker(size);
                break;
            case 7:
                worker = new JNIDoubleWorker(size);
                break;
        }
        return worker;
    }

    int random(int maxSize) {
        int res = LocalRandom.nextInt(maxSize);
        return res > 128 ? res : 128;
    }

    public static Object tmp;

    class GarbageProducer implements Runnable {

        private int maxSize;
        ExecutionController stresser;
        ByteArrayProducer bp;

        GarbageProducer(int size) {
            this.maxSize = size;
            bp = new ByteArrayProducer();
        }

        public void run() {
            if (stresser == null) {
                stresser = getExecutionController();
            }

            while (stresser.continueExecution()) {
                try {
                    byte[] arr = bp.create(random(maxSize));
                    tmp = arr;
                } catch (OutOfMemoryError oome) {
                    // Do nothing.
                }
            }
        }
    }

    abstract class JNIAbstractWorker extends JNIWorker implements Runnable {

        ExecutionController stresser;
        private int maxSize;

        public JNIAbstractWorker(int maxSize) {
            this.maxSize = maxSize;
        }

        public void check(boolean condition, String message) {
            if (!condition) {
                throw new Error(message);
            }
        }

        abstract void doit(int size);

        public void run() {
            // create array with random elements
            // store min and max element for further check
            // create new string
            // call JNI methods
            // check min/max as sort result
            // check string hash

            if (stresser == null) {
                stresser = getExecutionController();
            }
            while (stresser.continueExecution()) {
                // let make at least several values for long/float
                try {
                    doit(random(maxSize));
                } catch (OutOfMemoryError oome) {
                    // Do nothing.
                }
            }
        }
    }

    // BYTE
    class JNIBooleanWorker extends JNIAbstractWorker {

        BooleanArrayProducer gp = new BooleanArrayProducer();

        public JNIBooleanWorker(int size) {
            super(size);
        }

        void doit(int size) {

            boolean[] array = gp.create(size);
            // just to be sure that we have true & false
            array[0] = true;
            array[array.length - 1] = false;
            String str = "unsupported";
            int nativeHash = NativeCall(array, str);
            int javaHash = 0;
            for (int i = 0; i < str.length(); ++i) {
                javaHash += (int) str.charAt(i);
            }
            javaHash += javaHash;
            check(array[0] == false && array[array.length - 1] == true
                    && javaHash == nativeHash, "Data validation failure");

        }
    }

    class JNIByteWorker extends JNIAbstractWorker {

        ByteArrayProducer gp = new ByteArrayProducer();

        public JNIByteWorker(int size) {
            super(size);
        }

        void doit(int size) {

            byte[] array = gp.create(size);
            byte min = Byte.MAX_VALUE, max = Byte.MIN_VALUE;
            for (int i = 0; i < array.length; ++i) {
                if (array[i] > max) {
                    max = array[i];
                }

                if (array[i] < min) {
                    min = array[i];
                }
            }
            String str = "Min: " + min + " Max: " + max;
            int nativeHash = NativeCall(array, str);
            int javaHash = 0;
            for (int i = 0; i < str.length(); ++i) {
                javaHash += (int) str.charAt(i);
            }
            javaHash += javaHash;
            check(array[0] == min && array[array.length - 1] == max
                    && javaHash == nativeHash, "Data validation failure");

        }
    }

    // CHAR
    class JNICharWorker extends JNIAbstractWorker {

        CharArrayProducer gp = new CharArrayProducer();

        public JNICharWorker(int size) {
            super(size);
        }

        void doit(int size) {
            char[] array = gp.create(size);
            char min = 0xffff, max = 0;
            for (int i = 0; i < array.length; ++i) {
                array[i] = (char) LocalRandom.nextInt();
                if (array[i] > max) {
                    max = array[i];
                }

                if (array[i] < min) {
                    min = array[i];
                }
            }
            String str = "Min: " + min + " Max: " + max;
            int nativeHash = NativeCall(array, str);
            int javaHash = 0;
            for (int i = 0; i < str.length(); ++i) {
                javaHash += (int) str.charAt(i);
            }
            javaHash += javaHash;
            check(array[0] == min && array[array.length - 1] == max
                    && javaHash == nativeHash, "Data validation failure");

        }
    }

    // SHORT
    class JNIShortWorker extends JNIAbstractWorker {

        ShortArrayProducer gp = new ShortArrayProducer();

        public JNIShortWorker(int size) {
            super(size);
        }

        void doit(int size) {

            short[] array = gp.create(size);
            short min = Short.MAX_VALUE, max = Short.MIN_VALUE;
            for (int i = 0; i < array.length; ++i) {
                if (array[i] > max) {
                    max = array[i];
                }

                if (array[i] < min) {
                    min = array[i];
                }
            }
            String str = "Min: " + min + " Max: " + max;
            int nativeHash = NativeCall(array, str);
            int javaHash = 0;
            for (int i = 0; i < str.length(); ++i) {
                javaHash += (int) str.charAt(i);
            }
            javaHash += javaHash;
            check(array[0] == min && array[array.length - 1] == max
                    && javaHash == nativeHash, "Data validation failure");
        }
    }

    // INT
    class JNIIntWorker extends JNIAbstractWorker {

        IntArrayProducer gp = new IntArrayProducer();

        public JNIIntWorker(int size) {
            super(size);
        }

        void doit(int size) {
            int[] array = gp.create(size);
            int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
            for (int i = 0; i < array.length; ++i) {
                if (array[i] > max) {
                    max = array[i];
                }

                if (array[i] < min) {
                    min = array[i];
                }
            }
            String str = "Min: " + min + " Max: " + max;
            int nativeHash = NativeCall(array, str);
            int javaHash = 0;
            for (int i = 0; i < str.length(); ++i) {
                javaHash += (int) str.charAt(i);
            }
            javaHash += javaHash;
            check(array[0] == min && array[array.length - 1] == max
                    && javaHash == nativeHash, "Data validation failure");

        }
    }

    // LONG
    class JNILongWorker extends JNIAbstractWorker {

        LongArrayProducer gp = new LongArrayProducer();

        public JNILongWorker(int size) {
            super(size);
        }

        void doit(int size) {

            long[] array = gp.create(size);
            long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
            for (int i = 0; i < array.length; ++i) {
                if (array[i] > max) {
                    max = array[i];
                }

                if (array[i] < min) {
                    min = array[i];
                }
            }
            String str = "Min: " + min + " Max: " + max;
            int nativeHash = NativeCall(array, str);
            int javaHash = 0;
            for (int i = 0; i < str.length(); ++i) {
                javaHash += (int) str.charAt(i);
            }
            javaHash += javaHash;
            check(array[0] == min && array[array.length - 1] == max
                    && javaHash == nativeHash, "Data validation failure");

        }
    }

    // FLOAT
    class JNIFloatWorker extends JNIAbstractWorker {

        FloatArrayProducer gp = new FloatArrayProducer();

        public JNIFloatWorker(int size) {
            super(size);
        }

        void doit(int size) {

            float[] array = gp.create(size);
            float min = Float.MAX_VALUE, max = Float.MIN_VALUE;
            for (int i = 0; i < array.length; ++i) {
                if (array[i] > max) {
                    max = array[i];
                }

                if (array[i] < min) {
                    min = array[i];
                }
            }
            String str = "Min: " + min + " Max: " + max;
            int nativeHash = NativeCall(array, str);
            int javaHash = 0;
            for (int i = 0; i < str.length(); ++i) {
                javaHash += (int) str.charAt(i);
            }
            javaHash += javaHash;
            check(array[0] == min && array[array.length - 1] == max
                    && javaHash == nativeHash, "Data validation failure");
        }
    }

    // DOUBLE
    class JNIDoubleWorker extends JNIAbstractWorker {

        DoubleArrayProducer gp = new DoubleArrayProducer();

        public JNIDoubleWorker(int size) {
            super(size);
        }

        void doit(int size) {

            double[] array = gp.create(size);
            double min = Double.MAX_VALUE, max = Double.MIN_VALUE;
            for (int i = 0; i < array.length; ++i) {
                if (array[i] > max) {
                    max = array[i];
                }

                if (array[i] < min) {
                    min = array[i];
                }
            }
            String str = "Min: " + min + " Max: " + max;
            int nativeHash = NativeCall(array, str);
            int javaHash = 0;
            for (int i = 0; i < str.length(); ++i) {
                javaHash += (int) str.charAt(i);
            }
            javaHash += javaHash;
            check(array[0] == min && array[array.length - 1] == max
                    && javaHash == nativeHash, "Data validation failure");
        }
    }
}

class JNIWorker {

    protected native int NativeCall(boolean[] array, String str);

    protected native int NativeCall(byte[] array, String str);

    protected native int NativeCall(char[] array, String str);

    protected native int NativeCall(short[] array, String str);

    protected native int NativeCall(int[] array, String str);

    protected native int NativeCall(long[] array, String str);

    protected native int NativeCall(float[] array, String str);

    protected native int NativeCall(double[] array, String str);
}