xref: /frameworks/rs/tests/java_api/RsTest/src/com/android/rs/test/UT_reduce.java

/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* UT_reduce_backward.java is a much simpler version of this test
 * case that exercises pragmas after the functions (backward
 * reference), whereas this test case exercises the pragmas before
 * the functions (forward reference).
 */

package com.android.rs.test;

import android.content.Context;
import android.renderscript.Allocation;
import android.renderscript.Element;
import android.renderscript.Float2;
import android.renderscript.Int2;
import android.renderscript.Int3;
import android.renderscript.RenderScript;
import android.renderscript.ScriptIntrinsicHistogram;
import android.renderscript.Type;
import android.util.Log;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;

import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertTrue;

public class UT_reduce extends UnitTest {
    private static final String TAG = "reduce";

    protected UT_reduce(RSTestCore rstc, Context ctx) {
        super(rstc, "reduce", ctx);
    }

    private static class timing {
        timing(long myJavaStart, long myJavaEnd, long myRsStart,
               long myCopyStart, long myKernelStart, long myRsEnd,
               Allocation... myInputs) {
            javaStart = myJavaStart;
            javaEnd = myJavaEnd;
            rsStart = myRsStart;
            copyStart = myCopyStart;
            kernelStart = myKernelStart;
            rsEnd = myRsEnd;

            inputBytes = 0;
            for (Allocation input : myInputs)
                inputBytes += input.getBytesSize();

            inputCells = (myInputs.length > 0) ? myInputs[0].getType().getCount() : 0;
        }

        timing(long myInputCells) {
            inputCells = myInputCells;
        }

        private long javaStart = -1;
        private long javaEnd = -1;
        private long rsStart = -1;
        private long copyStart = -1;
        private long kernelStart = -1;
        private long rsEnd = -1;
        private long inputBytes = -1;
        private long inputCells = -1;

        public long javaTime() {
            return javaEnd - javaStart;
        }

        public long rsTime() {
            return rsEnd - rsStart;
        }

        public long kernelTime() {
            return rsEnd - kernelStart;
        }

        public long overheadTime() {
            return kernelStart - rsStart;
        }

        public long allocationTime() {
            return copyStart - rsStart;
        }

        public long copyTime() {
            return kernelStart - copyStart;
        }

        public static String string(long myJavaStart, long myJavaEnd, long myRsStart,
                                    long myCopyStart, long myKernelStart, long myRsEnd,
                                    Allocation... myInputs) {
            return (new timing(myJavaStart, myJavaEnd, myRsStart,
                    myCopyStart, myKernelStart, myRsEnd, myInputs)).string();
        }

        public static String string(long myInputCells) {
            return (new timing(myInputCells)).string();
        }

        public String string() {
            String result;
            if (javaStart >= 0) {
                result = "(java " + javaTime() + "ms, rs " + rsTime() + "ms = overhead " +
                        overheadTime() + "ms (alloc " + allocationTime() + "ms + copy " +
                        copyTime() + "ms) + kernel+get() " + kernelTime() + "ms)";
                if (inputCells > 0)
                    result += " ";
            } else {
                result = "";
            }
            if (inputCells > 0) {
                result += "(" + fmt.format(inputCells) + " cells";
                if (inputBytes > 0)
                    result += ", " + fmt.format(inputBytes) + " bytes";
                result += ")";
            }
            return result;
        }

        private static java.text.DecimalFormat fmt;

        static {
            fmt = new java.text.DecimalFormat("###,###");
        }
    }

    private byte[] createInputArrayByte(int len, int seed) {
        byte[] array = new byte[len];
        (new Random(seed)).nextBytes(array);
        return array;
    }

    private float[] createInputArrayFloat(int len, Random rand) {
        float[] array = new float[len];
        for (int i = 0; i < len; ++i) {
            final float val = rand.nextFloat();
            array[i] = rand.nextBoolean() ? val : -val;
        }
        return array;
    }

    private float[] createInputArrayFloat(int len, int seed) {
        return createInputArrayFloat(len, new Random(seed));
    }

    private float[] createInputArrayFloatWithInfs(int len, int infs, int seed) {
        Random rand = new Random(seed);
        float[] array = createInputArrayFloat(len, rand);
        for (int i = 0; i < infs; ++i)
            array[rand.nextInt(len)] = (rand.nextBoolean() ? Float.POSITIVE_INFINITY : Float.NEGATIVE_INFINITY);
        return array;
    }

    private int[] createInputArrayInt(int len, int seed) {
        Random rand = new Random(seed);
        int[] array = new int[len];
        for (int i = 0; i < len; ++i)
            array[i] = rand.nextInt();
        return array;
    }

    private int[] createInputArrayInt(int len, int seed, int eltRange) {
        Random rand = new Random(seed);
        int[] array = new int[len];
        for (int i = 0; i < len; ++i)
            array[i] = rand.nextInt(eltRange);
        return array;
    }

    private long[] intArrayToLong(final int[] input) {
        final long[] output = new long[input.length];

        for (int i = 0; i < input.length; ++i)
            output[i] = input[i];

        return output;
    }

    private <T extends Number> boolean result(String testName, final timing t,
                                              T javaResult, T rsResult) {
        final boolean success = javaResult.equals(rsResult);
        String status = (success ? "PASSED" : "FAILED");
        if (success && (t != null))
            status += " " + t.string();
        Log.i(TAG, testName + ": java " + javaResult + ", rs " + rsResult + ": " + status);
        return success;
    }

    private boolean result(String testName, final timing t,
                           final float[] javaResult, final float[] rsResult) {
        if (javaResult.length != rsResult.length) {
            Log.i(TAG, testName + ": java length " + javaResult.length +
                    ", rs length " + rsResult.length + ": FAILED");
            return false;
        }
        for (int i = 0; i < javaResult.length; ++i) {
            if (javaResult[i] != rsResult[i]) {
                Log.i(TAG, testName + "[" + i + "]: java " + javaResult[i] +
                        ", rs " + rsResult[i] + ": FAILED");
                return false;
            }
        }
        String status = "PASSED";
        if (t != null)
            status += " " + t.string();
        Log.i(TAG, testName + ": " + status);
        return true;
    }

    private boolean result(String testName, final timing t,
                           final long[] javaResult, final long[] rsResult) {
        if (javaResult.length != rsResult.length) {
            Log.i(TAG, testName + ": java length " + javaResult.length +
                    ", rs length " + rsResult.length + ": FAILED");
            return false;
        }
        for (int i = 0; i < javaResult.length; ++i) {
            if (javaResult[i] != rsResult[i]) {
                Log.i(TAG, testName + "[" + i + "]: java " + javaResult[i] +
                        ", rs " + rsResult[i] + ": FAILED");
                return false;
            }
        }
        String status = "PASSED";
        if (t != null)
            status += " " + t.string();
        Log.i(TAG, testName + ": " + status);
        return true;
    }

    private boolean result(String testName, final timing t,
                           final int[] javaResult, final int[] rsResult) {
        return result(testName, t, intArrayToLong(javaResult), intArrayToLong(rsResult));
    }

    private boolean result(String testName, final timing t, Int2 javaResult, Int2 rsResult) {
        final boolean success = (javaResult.x == rsResult.x) && (javaResult.y == rsResult.y);
        String status = (success ? "PASSED" : "FAILED");
        if (success && (t != null))
            status += " " + t.string();
        Log.i(TAG,
                testName +
                        ": java (" + javaResult.x + ", " + javaResult.y + ")" +
                        ", rs (" + rsResult.x + ", " + rsResult.y + ")" +
                        ": " + status);
        return success;
    }

    private boolean result(String testName, final timing t, Float2 javaResult, Float2 rsResult) {
        final boolean success = (javaResult.x == rsResult.x) && (javaResult.y == rsResult.y);
        String status = (success ? "PASSED" : "FAILED");
        if (success && (t != null))
            status += " " + t.string();
        Log.i(TAG,
                testName +
                        ": java (" + javaResult.x + ", " + javaResult.y + ")" +
                        ", rs (" + rsResult.x + ", " + rsResult.y + ")" +
                        ": " + status);
        return success;
    }

    ///////////////////////////////////////////////////////////////////

    private int addint(int[] input) {
        int result = 0;
        for (int idx = 0; idx < input.length; ++idx)
            result += input[idx];
        return result;
    }

    private boolean addint1D_array(RenderScript RS, ScriptC_reduce s, int seed, int[] size) {
        final int[] input = createInputArrayInt(size[0], seed, Integer.MAX_VALUE / size[0]);

        final int javaResult = addint(input);
        final int rsResult = s.reduce_addint(input).get();

        return result("addint1D_array", new timing(size[0]), javaResult, rsResult);
    }

    private boolean addint1D(RenderScript RS, ScriptC_reduce s, int seed, int[] size) {
        final int[] inputArray = createInputArrayInt(size[0], seed, Integer.MAX_VALUE / size[0]);

        final long javaTimeStart = java.lang.System.currentTimeMillis();
        final int javaResult = addint(inputArray);
        final long javaTimeEnd = java.lang.System.currentTimeMillis();

        final long rsTimeStart = java.lang.System.currentTimeMillis();

        Allocation inputAllocation = Allocation.createSized(RS, Element.I32(RS), inputArray.length);

        final long copyTimeStart = java.lang.System.currentTimeMillis();

        inputAllocation.copyFrom(inputArray);

        final long kernelTimeStart = java.lang.System.currentTimeMillis();
        final int rsResult = s.reduce_addint(inputAllocation).get();
        final long rsTimeEnd = java.lang.System.currentTimeMillis();

        final boolean success =
                result("addint1D",
                        new timing(javaTimeStart, javaTimeEnd, rsTimeStart,
                                copyTimeStart, kernelTimeStart, rsTimeEnd, inputAllocation),
                        javaResult, rsResult);
        inputAllocation.destroy();
        return success;
    }

    private boolean addint2D(RenderScript RS, ScriptC_reduce s, int seed, int[] size) {
        final int dimX = size[0];
        final int dimY = size[1];

        final int[] inputArray = createInputArrayInt(dimX * dimY, seed, Integer.MAX_VALUE / (dimX * dimY));

        final long javaTimeStart = java.lang.System.currentTimeMillis();
        final int javaResult = addint(inputArray);
        final long javaTimeEnd = java.lang.System.currentTimeMillis();

        final long rsTimeStart = java.lang.System.currentTimeMillis();

        Type.Builder typeBuilder = new Type.Builder(RS, Element.I32(RS));
        typeBuilder.setX(dimX).setY(dimY);
        Allocation inputAllocation = Allocation.createTyped(RS, typeBuilder.create());

        final long copyTimeStart = java.lang.System.currentTimeMillis();

        inputAllocation.copy2DRangeFrom(0, 0, dimX, dimY, inputArray);

        final long kernelTimeStart = java.lang.System.currentTimeMillis();
        final int rsResult = s.reduce_addint(inputAllocation).get();
        final long rsTimeEnd = java.lang.System.currentTimeMillis();

        final boolean success =
                result("addint2D",
                        new timing(javaTimeStart, javaTimeEnd, rsTimeStart,
                                copyTimeStart, kernelTimeStart, rsTimeEnd, inputAllocation),
                        javaResult, rsResult);
        inputAllocation.destroy();
        return success;
    }

    private boolean addint3D(RenderScript RS, ScriptC_reduce s, int seed, int[] size) {
        final int dimX = size[0];
        final int dimY = size[1];
        final int dimZ = size[2];

        final int[] inputArray = createInputArrayInt(dimX * dimY * dimZ, seed, Integer.MAX_VALUE / (dimX * dimY * dimZ));

        final long javaTimeStart = java.lang.System.currentTimeMillis();
        final int javaResult = addint(inputArray);
        final long javaTimeEnd = java.lang.System.currentTimeMillis();

        final long rsTimeStart = java.lang.System.currentTimeMillis();

        Type.Builder typeBuilder = new Type.Builder(RS, Element.I32(RS));
        typeBuilder.setX(dimX).setY(dimY).setZ(dimZ);
        Allocation inputAllocation = Allocation.createTyped(RS, typeBuilder.create());

        final long copyTimeStart = java.lang.System.currentTimeMillis();

        inputAllocation.copy3DRangeFrom(0, 0, 0, dimX, dimY, dimZ, inputArray);

        final long kernelTimeStart = java.lang.System.currentTimeMillis();
        final int rsResult = s.reduce_addint(inputAllocation).get();
        final long rsTimeEnd = java.lang.System.currentTimeMillis();

        final boolean success =
                result("addint3D",
                        new timing(javaTimeStart, javaTimeEnd, rsTimeStart,
                                copyTimeStart, kernelTimeStart, rsTimeEnd, inputAllocation),
                        javaResult, rsResult);
        inputAllocation.destroy();
        return success;
    }

    //-----------------------------------------------------------------

    private boolean patternInterleavedReduce(RenderScript RS, ScriptC_reduce s) {
        // Run two reduce operations without forcing completion between them.
        // We want to ensure that the driver can handle this, and that
        // temporary Allocations created to run the reduce operations survive
        // until get().

        boolean pass = true;

        final int inputSize = (1 << 18);

        final int[] input1 = createInputArrayInt(123, Integer.MAX_VALUE / inputSize);
        final int[] input2 = createInputArrayInt(456, Integer.MAX_VALUE / inputSize);

        final int javaResult1 = addint(input1);
        final int javaResult2 = addint(input2);

        final ScriptC_reduce.result_int rsResultFuture1 = s.reduce_addint(input1);
        final ScriptC_reduce.result_int rsResultFuture2 = s.reduce_addint(input2);

        pass &= result("patternInterleavedReduce (1)", new timing(inputSize),
                javaResult1, rsResultFuture1.get());
        pass &= result("patternInterleavedReduce (2)", new timing(inputSize),
                javaResult2, rsResultFuture2.get());

        return pass;
    }

    //-----------------------------------------------------------------

    private int[] sillySumIntoDecArray(final int[] input) {
        final int resultScalar = addint(input);
        final int[] result = new int[4];
        for (int i = 0; i < 4; ++i)
            result[i] = resultScalar / (i + 1);
        return result;
    }

    private int[] sillySumIntoIncArray(final int[] input) {
        final int resultScalar = addint(input);
        final int[] result = new int[4];
        for (int i = 0; i < 4; ++i)
            result[i] = resultScalar / (4 - i);
        return result;
    }

    private boolean patternDuplicateAnonymousResult(RenderScript RS, ScriptC_reduce s) {
        // Ensure that we can have two kernels with the same anonymous result type.

        boolean pass = true;

        final int inputSize = 1000;
        final int[] input = createInputArrayInt(149, Integer.MAX_VALUE / inputSize);

        final int[] javaResultDec = sillySumIntoDecArray(input);
        final int[] rsResultDec = s.reduce_sillySumIntoDecArray(input).get();
        pass &= result("patternDuplicateAnonymousResult (Dec)", new timing(inputSize),
                javaResultDec, rsResultDec);

        final int[] javaResultInc = sillySumIntoIncArray(input);
        final int[] rsResultInc = s.reduce_sillySumIntoIncArray(input).get();
        pass &= result("patternDuplicateAnonymousResult (Inc)", new timing(inputSize),
                javaResultInc, rsResultInc);

        return pass;
    }

    ///////////////////////////////////////////////////////////////////

    private float findMinAbs(float[] input) {
        float accum = input[0];
        for (int idx = 1; idx < input.length; ++idx) {
            final float val = input[idx];
            if (Math.abs(val) < Math.abs(accum))
                accum = val;
        }
        return accum;
    }

    static interface ReduceFindMinAbs {
        float run(Allocation input);
    }

    private boolean findMinAbs(RenderScript RS, float[] inputArray, String testName, ReduceFindMinAbs reduction) {
        final long javaTimeStart = java.lang.System.currentTimeMillis();
        final float javaResult = findMinAbs(inputArray);
        final long javaTimeEnd = java.lang.System.currentTimeMillis();

        final long rsTimeStart = java.lang.System.currentTimeMillis();

        Allocation inputAllocation = Allocation.createSized(RS, Element.F32(RS), inputArray.length);

        final long copyTimeStart = java.lang.System.currentTimeMillis();

        inputAllocation.copyFrom(inputArray);

        final long kernelTimeStart = java.lang.System.currentTimeMillis();
        final float rsResult = reduction.run(inputAllocation);
        final long rsTimeEnd = java.lang.System.currentTimeMillis();

        // Note that the Java and RenderScript algorithms are not
        // guaranteed to find the same results -- but the results
        // should have the same absolute value.

        final boolean success =
                result(testName,
                        new timing(javaTimeStart, javaTimeEnd, rsTimeStart,
                                copyTimeStart, kernelTimeStart, rsTimeEnd, inputAllocation),
                        Math.abs(javaResult), Math.abs(rsResult));
        inputAllocation.destroy();
        return success;
    }

    private boolean findMinAbsBool(RenderScript RS, ScriptC_reduce s, int seed, int[] size) {
        return findMinAbs(RS, createInputArrayFloat(size[0], seed), "findMinAbsBool",
                (Allocation input) -> s.reduce_findMinAbsBool(input).get());
    }

    private boolean findMinAbsBoolInf(RenderScript RS, ScriptC_reduce s, int seed, int[] size) {
        return findMinAbs(RS, createInputArrayFloatWithInfs(size[0], 1 + size[0] / 1000, seed), "findMinAbsBoolInf",
                (Allocation input) -> s.reduce_findMinAbsBool(input).get());
    }

    private boolean findMinAbsNaN(RenderScript RS, ScriptC_reduce s, int seed, int[] size) {
        return findMinAbs(RS, createInputArrayFloat(size[0], seed), "findMinAbsNaN",
                (Allocation input) -> s.reduce_findMinAbsNaN(input).get());
    }

    private boolean findMinAbsNaNInf(RenderScript RS, ScriptC_reduce s, int seed, int[] size) {
        return findMinAbs(RS, createInputArrayFloatWithInfs(size[0], 1 + size[0] / 1000, seed), "findMinAbsNaNInf",
                (Allocation input) -> s.reduce_findMinAbsNaN(input).get());
    }

    ///////////////////////////////////////////////////////////////////

    private Int2 findMinAndMax(float[] input) {
        float minVal = Float.POSITIVE_INFINITY;
        int minIdx = -1;
        float maxVal = Float.NEGATIVE_INFINITY;
        int maxIdx = -1;

        for (int idx = 0; idx < input.length; ++idx) {
            if ((minIdx < 0) || (input[idx] < minVal)) {
                minVal = input[idx];
                minIdx = idx;
            }
            if ((maxIdx < 0) || (input[idx] > maxVal)) {
                maxVal = input[idx];
                maxIdx = idx;
            }
        }

        return new Int2(minIdx, maxIdx);
    }

    private boolean findMinAndMax_array(RenderScript RS, ScriptC_reduce s, int seed, int[] size) {
        final float[] input = createInputArrayFloat(size[0], seed);

        final Int2 javaResult = findMinAndMax(input);
        final Int2 rsResult = s.reduce_findMinAndMax(input).get();

        // Note that the Java and RenderScript algorithms are not
        // guaranteed to find the same cells -- but they should
        // find cells of the same value.
        final Float2 javaVal = new Float2(input[javaResult.x], input[javaResult.y]);
        final Float2 rsVal = new Float2(input[rsResult.x], input[rsResult.y]);

        return result("findMinAndMax_array", new timing(size[0]), javaVal, rsVal);
    }

    private boolean findMinAndMax(RenderScript RS, ScriptC_reduce s, int seed, int[] size) {
        final float[] inputArray = createInputArrayFloat(size[0], seed);

        final long javaTimeStart = java.lang.System.currentTimeMillis();
        final Int2 javaResult = findMinAndMax(inputArray);
        final long javaTimeEnd = java.lang.System.currentTimeMillis();

        final long rsTimeStart = java.lang.System.currentTimeMillis();

        Allocation inputAllocation = Allocation.createSized(RS, Element.F32(RS), inputArray.length);

        final long copyTimeStart = java.lang.System.currentTimeMillis();

        inputAllocation.copyFrom(inputArray);

        final long kernelTimeStart = java.lang.System.currentTimeMillis();
        final Int2 rsResult = s.reduce_findMinAndMax(inputAllocation).get();
        final long rsTimeEnd = java.lang.System.currentTimeMillis();

        // Note that the Java and RenderScript algorithms are not
        // guaranteed to find the same cells -- but they should
        // find cells of the same value.
        final Float2 javaVal = new Float2(inputArray[javaResult.x], inputArray[javaResult.y]);
        final Float2 rsVal = new Float2(inputArray[rsResult.x], inputArray[rsResult.y]);

        final boolean success =
                result("findMinAndMax",
                        new timing(javaTimeStart, javaTimeEnd, rsTimeStart,
                                copyTimeStart, kernelTimeStart, rsTimeEnd, inputAllocation),
                        javaVal, rsVal);
        inputAllocation.destroy();
        return success;
    }

    //-----------------------------------------------------------------

    private boolean patternFindMinAndMaxInf(RenderScript RS, ScriptC_reduce s) {
        // Run this kernel on an input consisting solely of a single infinity.

        final float[] input = new float[1];
        input[0] = Float.POSITIVE_INFINITY;

        final Int2 javaResult = findMinAndMax(input);
        final Int2 rsResult = s.reduce_findMinAndMax(input).get();

        // Note that the Java and RenderScript algorithms are not
        // guaranteed to find the same cells -- but they should
        // find cells of the same value.
        final Float2 javaVal = new Float2(input[javaResult.x], input[javaResult.y]);
        final Float2 rsVal = new Float2(input[rsResult.x], input[rsResult.y]);

        return result("patternFindMinAndMaxInf", new timing(1), javaVal, rsVal);
    }

    ///////////////////////////////////////////////////////////////////

    // Both the input and the result are linearized representations of matSize*matSize matrices.
    private float[] findMinMat(final float[] inputArray, final int matSize) {
        final int matSizeSquared = matSize * matSize;

        float[] result = new float[matSizeSquared];
        for (int i = 0; i < matSizeSquared; ++i)
            result[i] = Float.POSITIVE_INFINITY;

        for (int i = 0; i < inputArray.length; ++i)
            result[i % matSizeSquared] = Math.min(result[i % matSizeSquared], inputArray[i]);

        return result;
    }

    static interface ReduceFindMinMat {
        float[] run(Allocation input);
    }

    private boolean findMinMat(RenderScript RS, int seed, int[] inputSize,
                               int matSize, Element matElement, ReduceFindMinMat reduction) {
        final int length = inputSize[0];
        final int matSizeSquared = matSize * matSize;

        final float[] inputArray = createInputArrayFloat(matSizeSquared * length, seed);

        final long javaTimeStart = java.lang.System.currentTimeMillis();
        final float[] javaResult = findMinMat(inputArray, matSize);
        final long javaTimeEnd = java.lang.System.currentTimeMillis();

        final long rsTimeStart = java.lang.System.currentTimeMillis();

        Allocation inputAllocation = Allocation.createSized(RS, matElement, length);

        final long copyTimeStart = java.lang.System.currentTimeMillis();

        inputAllocation.copyFromUnchecked(inputArray);

        final long kernelTimeStart = java.lang.System.currentTimeMillis();
        final float[] rsResult = reduction.run(inputAllocation);
        final long rsTimeEnd = java.lang.System.currentTimeMillis();

        final boolean success =
                result("findMinMat" + matSize,
                        new timing(javaTimeStart, javaTimeEnd, rsTimeStart,
                                copyTimeStart, kernelTimeStart, rsTimeEnd, inputAllocation),
                        javaResult, rsResult);
        inputAllocation.destroy();
        return success;
    }

    private boolean findMinMat2(RenderScript RS, ScriptC_reduce s, int seed, int[] size) {
        return findMinMat(RS, seed, size, 2, Element.MATRIX_2X2(RS),
                (Allocation input) -> s.reduce_findMinMat2(input).get());
    }

    private boolean findMinMat4(RenderScript RS, ScriptC_reduce s, int seed, int[] size) {
        return findMinMat(RS, seed, size, 4, Element.MATRIX_4X4(RS),
                (Allocation input) -> s.reduce_findMinMat4(input).get());
    }

    ///////////////////////////////////////////////////////////////////

    private int fz(final int[] input) {
        for (int i = 0; i < input.length; ++i)
            if (input[i] == 0)
                return i;
        return -1;
    }

    private boolean fz_array(RenderScript RS, ScriptC_reduce s, int seed, int size[]) {
        final int inputLen = size[0];
        int[] input = createInputArrayInt(inputLen, seed + 0);
        // just in case we got unlucky
        input[(new Random(seed + 1)).nextInt(inputLen)] = 0;

        final int rsResult = s.reduce_fz(input).get();

        final boolean success = (input[rsResult] == 0);
        Log.i(TAG,
                "fz_array: input[" + rsResult + "] == " + input[rsResult] + ": " +
                        (success ? "PASSED " + timing.string(size[0]) : "FAILED"));
        return success;
    }

    private boolean fz(RenderScript RS, ScriptC_reduce s, int seed, int size[]) {
        final int inputLen = size[0];
        int[] inputArray = createInputArrayInt(inputLen, seed + 0);
        // just in case we got unlucky
        inputArray[(new Random(seed + 1)).nextInt(inputLen)] = 0;

        final long javaTimeStart = java.lang.System.currentTimeMillis();
        final int javaResult = fz(inputArray);
        final long javaTimeEnd = java.lang.System.currentTimeMillis();

        final long rsTimeStart = java.lang.System.currentTimeMillis();

        Allocation inputAllocation = Allocation.createSized(RS, Element.I32(RS), inputArray.length);

        final long copyTimeStart = java.lang.System.currentTimeMillis();

        inputAllocation.copyFrom(inputArray);

        final long kernelTimeStart = java.lang.System.currentTimeMillis();
        final int rsResult = s.reduce_fz(inputAllocation).get();
        final long rsTimeEnd = java.lang.System.currentTimeMillis();

        final boolean success = (inputArray[rsResult] == 0);
        String status = (success ? "PASSED" : "FAILED");
        if (success)
            status += " " + timing.string(javaTimeStart, javaTimeEnd, rsTimeStart,
                    copyTimeStart, kernelTimeStart, rsTimeEnd, inputAllocation);
        Log.i(TAG,
                "fz: java input[" + javaResult + "] == " + inputArray[javaResult] +
                        ", rs input[" + rsResult + "] == " + inputArray[javaResult] + ": " + status);
        inputAllocation.destroy();
        return success;
    }

    ///////////////////////////////////////////////////////////////////

    private boolean fz2(RenderScript RS, ScriptC_reduce s, int seed, int size[]) {
        final int dimX = size[0], dimY = size[1];
        final int inputLen = dimX * dimY;

        int[] inputArray = createInputArrayInt(inputLen, seed + 0);
        // just in case we got unlucky
        inputArray[(new Random(seed + 1)).nextInt(inputLen)] = 0;

        final long javaTimeStart = java.lang.System.currentTimeMillis();
        final int javaResultLinear = fz(inputArray);
        final long javaTimeEnd = java.lang.System.currentTimeMillis();

        final Int2 javaResult = new Int2(javaResultLinear % dimX, javaResultLinear / dimX);
        final int javaCellVal = inputArray[javaResult.x + dimX * javaResult.y];

        final long rsTimeStart = java.lang.System.currentTimeMillis();

        Type.Builder typeBuilder = new Type.Builder(RS, Element.I32(RS));
        typeBuilder.setX(dimX).setY(dimY);
        Allocation inputAllocation = Allocation.createTyped(RS, typeBuilder.create());

        final long copyTimeStart = java.lang.System.currentTimeMillis();

        inputAllocation.copy2DRangeFrom(0, 0, dimX, dimY, inputArray);

        final long kernelTimeStart = java.lang.System.currentTimeMillis();
        final Int2 rsResult = s.reduce_fz2(inputAllocation).get();
        final long rsTimeEnd = java.lang.System.currentTimeMillis();

        final int rsCellVal = inputArray[rsResult.x + dimX * rsResult.y];
        final boolean success = (rsCellVal == 0);
        String status = (success ? "PASSED" : "FAILED");
        if (success)
            status += " " + timing.string(javaTimeStart, javaTimeEnd, rsTimeStart,
                    copyTimeStart, kernelTimeStart, rsTimeEnd, inputAllocation);
        Log.i(TAG,
                "fz2: java input[" + javaResult.x + ", " + javaResult.y + "] == " + javaCellVal +
                        ", rs input[" + rsResult.x + ", " + rsResult.y + "] == " + rsCellVal + ": " + status);
        inputAllocation.destroy();
        return success;
    }

    ///////////////////////////////////////////////////////////////////

    private boolean fz3(RenderScript RS, ScriptC_reduce s, int seed, int[] size) {
        final int dimX = size[0], dimY = size[1], dimZ = size[2];
        final int inputLen = dimX * dimY * dimZ;

        int[] inputArray = createInputArrayInt(inputLen, seed + 0);
        // just in case we got unlucky
        inputArray[(new Random(seed + 1)).nextInt(inputLen)] = 0;

        final long javaTimeStart = java.lang.System.currentTimeMillis();
        final int javaResultLinear = fz(inputArray);
        final long javaTimeEnd = java.lang.System.currentTimeMillis();

        final Int3 javaResult = new Int3(
                javaResultLinear % dimX,
                (javaResultLinear / dimX) % dimY,
                javaResultLinear / (dimX * dimY));
        final int javaCellVal = inputArray[javaResult.x + dimX * javaResult.y + dimX * dimY * javaResult.z];

        final long rsTimeStart = java.lang.System.currentTimeMillis();

        Type.Builder typeBuilder = new Type.Builder(RS, Element.I32(RS));
        typeBuilder.setX(dimX).setY(dimY).setZ(dimZ);
        Allocation inputAllocation = Allocation.createTyped(RS, typeBuilder.create());

        final long copyTimeStart = java.lang.System.currentTimeMillis();

        inputAllocation.copy3DRangeFrom(0, 0, 0, dimX, dimY, dimZ, inputArray);

        final long kernelTimeStart = java.lang.System.currentTimeMillis();
        final Int3 rsResult = s.reduce_fz3(inputAllocation).get();
        final long rsTimeEnd = java.lang.System.currentTimeMillis();

        final int rsCellVal = inputArray[rsResult.x + dimX * rsResult.y + dimX * dimY * rsResult.z];
        final boolean success = (rsCellVal == 0);
        String status = (success ? "PASSED" : "FAILED");
        if (success)
            status += " " + timing.string(javaTimeStart, javaTimeEnd, rsTimeStart,
                    copyTimeStart, kernelTimeStart, rsTimeEnd, inputAllocation);
        Log.i(TAG,
                "fz3: java input[" + javaResult.x + ", " + javaResult.y + ", " + javaResult.z + "] == " + javaCellVal +
                        ", rs input[" + rsResult.x + ", " + rsResult.y + ", " + rsResult.z + "] == " + rsCellVal + ": " + status);
        inputAllocation.destroy();
        return success;
    }

    ///////////////////////////////////////////////////////////////////

    private static final int histogramBucketCount = 256;

    private long[] histogram(RenderScript RS, final byte[] inputArray) {
        Allocation inputAllocation = Allocation.createSized(RS, Element.U8(RS), inputArray.length);
        inputAllocation.copyFrom(inputArray);

        Allocation outputAllocation = Allocation.createSized(RS, Element.U32(RS), histogramBucketCount);

        ScriptIntrinsicHistogram scriptHsg = ScriptIntrinsicHistogram.create(RS, Element.U8(RS));
        scriptHsg.setOutput(outputAllocation);
        scriptHsg.forEach(inputAllocation);

        int[] outputArrayMistyped = new int[histogramBucketCount];
        outputAllocation.copyTo(outputArrayMistyped);

        long[] outputArray = new long[histogramBucketCount];
        for (int i = 0; i < histogramBucketCount; ++i)
            outputArray[i] = outputArrayMistyped[i] & (long) 0xffffffff;

        inputAllocation.destroy();
        outputAllocation.destroy();

        scriptHsg.destroy();
        return outputArray;
    }

    private boolean histogram_array(RenderScript RS, ScriptC_reduce s, int seed, int size[]) {
        final byte[] inputArray = createInputArrayByte(size[0], seed);

        final long[] javaResult = histogram(RS, inputArray);
        assertEquals("javaResult length", histogramBucketCount, javaResult.length);
        final long[] rsResult = s.reduce_histogram(inputArray).get();
        assertEquals("rsResult length", histogramBucketCount, rsResult.length);

        return result("histogram_array", new timing(size[0]), javaResult, rsResult);
    }

    private boolean histogram(RenderScript RS, ScriptC_reduce s, int seed, int size[]) {
        final byte[] inputArray = createInputArrayByte(size[0], seed);

        final long javaTimeStart = java.lang.System.currentTimeMillis();
        final long[] javaResult = histogram(RS, inputArray);
        final long javaTimeEnd = java.lang.System.currentTimeMillis();
        assertEquals("javaResult length", histogramBucketCount, javaResult.length);

        final long rsTimeStart = java.lang.System.currentTimeMillis();

        Allocation inputAllocation = Allocation.createSized(RS, Element.U8(RS), inputArray.length);

        final long copyTimeStart = java.lang.System.currentTimeMillis();

        inputAllocation.copyFrom(inputArray);

        final long kernelTimeStart = java.lang.System.currentTimeMillis();
        final long[] rsResult = s.reduce_histogram(inputAllocation).get();
        final long rsTimeEnd = java.lang.System.currentTimeMillis();
        assertEquals("rsResult length", histogramBucketCount, rsResult.length);

        // NOTE: The "java time" is actually for the RenderScript histogram intrinsic
        final boolean success =
                result("histogram",
                        new timing(javaTimeStart, javaTimeEnd, rsTimeStart,
                                copyTimeStart, kernelTimeStart, rsTimeEnd, inputAllocation),
                        javaResult, rsResult);
        inputAllocation.destroy();
        return success;
    }

    //-----------------------------------------------------------------

    private boolean patternRedundantGet(RenderScript RS, ScriptC_reduce s) {
        // Ensure that get() can be called multiple times on the same
        // result, and returns the same object each time.

        boolean pass = true;

        final int inputLength = 1 << 18;
        final byte[] inputArray = createInputArrayByte(inputLength, 789);

        final long[] javaResult = histogram(RS, inputArray);
        assertEquals("javaResult length", histogramBucketCount, javaResult.length);

        final ScriptC_reduce.resultArray256_uint rsResultFuture = s.reduce_histogram(inputArray);
        final long[] rsResult1 = rsResultFuture.get();
        assertEquals("rsResult1 length", histogramBucketCount, rsResult1.length);
        pass &= result("patternRedundantGet (1)", new timing(inputLength), javaResult, rsResult1);

        final long[] rsResult2 = rsResultFuture.get();
        pass &= result("patternRedundantGet (2)", new timing(inputLength), javaResult, rsResult2);

        final boolean success = (rsResult1 == rsResult2);
        Log.i(TAG, "patternRedundantGet (object equality): " + (success ? "PASSED" : "FAILED"));
        pass &= success;

        return pass;
    }

    //-----------------------------------------------------------------

    private Int2 mode(RenderScript RS, final byte[] inputArray) {
        long[] hsg = histogram(RS, inputArray);

        int modeIdx = 0;
        for (int i = 1; i < hsg.length; ++i)
            if (hsg[i] > hsg[modeIdx]) modeIdx = i;
        return new Int2(modeIdx, (int) hsg[modeIdx]);
    }

    private boolean mode_array(RenderScript RS, ScriptC_reduce s, int seed, int size[]) {
        final byte[] inputArray = createInputArrayByte(size[0], seed);

        final Int2 javaResult = mode(RS, inputArray);
        final Int2 rsResult = s.reduce_mode(inputArray).get();

        return result("mode", new timing(size[0]), javaResult, rsResult);
    }

    ///////////////////////////////////////////////////////////////////

    private long sumgcd(final int in1[], final int in2[]) {
        assertEquals("sumgcd input lengths", in1.length, in2.length);

        long sum = 0;
        for (int i = 0; i < in1.length; ++i) {
            int a = in1[i], b = in2[i];

            while (b != 0) {
                final int aNew = b;
                final int bNew = a % b;

                a = aNew;
                b = bNew;
            }

            sum += a;
        }
        return sum;
    }

    private boolean sumgcd(RenderScript RS, ScriptC_reduce s, int seed, int size[]) {
        final int len = size[0];

        final int[] inputArrayA = createInputArrayInt(len, seed + 0);
        final int[] inputArrayB = createInputArrayInt(len, seed + 1);

        final long javaTimeStart = java.lang.System.currentTimeMillis();
        final long javaResult = sumgcd(inputArrayA, inputArrayB);
        final long javaTimeEnd = java.lang.System.currentTimeMillis();

        final long rsTimeStart = java.lang.System.currentTimeMillis();

        Allocation inputAllocationA = Allocation.createSized(RS, Element.I32(RS), len);
        Allocation inputAllocationB = Allocation.createSized(RS, Element.I32(RS), len);

        final long copyTimeStart = java.lang.System.currentTimeMillis();

        inputAllocationA.copyFrom(inputArrayA);
        inputAllocationB.copyFrom(inputArrayB);

        final long kernelTimeStart = java.lang.System.currentTimeMillis();
        final long rsResult = s.reduce_sumgcd(inputAllocationA, inputAllocationB).get();
        final long rsTimeEnd = java.lang.System.currentTimeMillis();

        final boolean success =
                result("sumgcd",
                        new timing(javaTimeStart, javaTimeEnd, rsTimeStart, copyTimeStart, kernelTimeStart, rsTimeEnd,
                                inputAllocationA, inputAllocationB),
                        javaResult, rsResult);
        inputAllocationA.destroy();
        inputAllocationB.destroy();
        return success;
    }

    ///////////////////////////////////////////////////////////////////

    // Return an array of sparse integer values from 0 to maxVal inclusive.
    // The array consists of all values k*sparseness (k a nonnegative integer)
    // that are less than maxVal, and maxVal itself.  For example, if maxVal
    // is 20 and sparseness is 6, then the result is { 0, 6, 12, 18, 20 };
    // and if maxVal is 20 and sparseness is 10, then the result is { 0, 10, 20 }.
    //
    // The elements of the array are sorted in increasing order.
    //
    // maxVal     -- must be nonnegative
    // sparseness -- must be positive
    private static int[] computeSizePoints(int maxVal, int sparseness) {
        assertTrue((maxVal >= 0) && (sparseness > 0));

        final boolean maxValIsExtra = ((maxVal % sparseness) != 0);
        int[] result = new int[1 + maxVal / sparseness + (maxValIsExtra ? 1 : 0)];

        for (int i = 0; i * sparseness <= maxVal; ++i)
            result[i] = i * sparseness;
        if (maxValIsExtra)
            result[result.length - 1] = maxVal;

        return result;
    }

    private static final int maxSeedsPerTest = 10;

    static interface Test {
        // A test execution is characterized by two properties: A seed
        // and a size.
        //
        // The seed is used for generating pseudorandom input data.
        // Ideally, we use different seeds for different tests and for
        // different executions of the same test at different sizes.
        // A test with multiple blocks of input data (i.e., for a
        // reduction with multiple inputs) may want multiple seeds; it
        // may use the seeds seed..seed+maxSeedsPerTest-1.
        //
        // The size indicates the amount of input data.  It is the number
        // of cells in a particular dimension of the iteration space.
        boolean run(RenderScript RS, ScriptC_reduce s, int seed, int[] size);
    }

    static class TestDescription {
        public TestDescription(String myTestName, Test myTest, int mySeed, int[] myDefSize,
                               int myLog2MaxSize, int mySparseness) {
            testName = myTestName;
            test = myTest;
            seed = mySeed;
            defSize = myDefSize;
            log2MaxSize = myLog2MaxSize;
            sparseness = mySparseness;
        }

        public TestDescription(String myTestName, Test myTest, int mySeed, int[] myDefSize, int myLog2MaxSize) {
            testName = myTestName;
            test = myTest;
            seed = mySeed;
            defSize = myDefSize;
            log2MaxSize = myLog2MaxSize;
            sparseness = 1;
        }

        public TestDescription(String myTestName, Test myTest, int mySeed, int[] myDefSize) {
            testName = myTestName;
            test = myTest;
            seed = mySeed;
            defSize = myDefSize;
            log2MaxSize = -1;
            sparseness = 1;
        }

        public final String testName;

        public final Test test;

        // When executing the test, scale this up by maxSeedsPerTest.
        public final int seed;

        // If we're only going to run the test once, what size should
        // we use?  The length of the array is the number of
        // dimensions of the input data.
        public final int[] defSize;

        // If we're going to run the test over a range of sizes, what
        // is the maximum size to use?  (This constrains the number of
        // cells of the input data, not the number of cells ALONG A
        // PARTICULAR DIMENSION of the input data.)
        public final int log2MaxSize;

        // If we're going to run the test "exhaustively" over a range
        // of sizes, what is the size of a step through the range?
        //
        // For 1D, must be 1.
        public final int sparseness;
    }

    private boolean run(TestDescription td, RenderScript RS, ScriptC_reduce s, int seed, int[] size) {
        String arrayContent = "";
        for (int i = 0; i < size.length; ++i) {
            if (i != 0)
                arrayContent += ", ";
            arrayContent += size[i];
        }
        Log.i(TAG, "Running " + td.testName + "(seed = " + seed + ", size[] = {" + arrayContent + "})");
        return td.test.run(RS, s, seed, size);
    }

    private final TestDescription[] correctnessTests = {
            // alloc and array variants of the same test will use the same
            // seed, in case results need to be compared.

            new TestDescription("addint1D", this::addint1D, 0, new int[]{100000}, 20),
            new TestDescription("addint1D_array", this::addint1D_array, 0, new int[]{100000}, 20),
            new TestDescription("addint2D", this::addint2D, 1, new int[]{450, 225}, 20, 5),
            new TestDescription("addint3D", this::addint3D, 2, new int[]{37, 48, 49}, 20, 7),

            // Bool and NaN variants of the same test will use the same
            // seed, in case results need to be compared.
            new TestDescription("findMinAbsBool", this::findMinAbsBool, 3, new int[]{100000}, 20),
            new TestDescription("findMinAbsNaN", this::findMinAbsNaN, 3, new int[]{100000}, 20),
            new TestDescription("findMinAbsBoolInf", this::findMinAbsBoolInf, 4, new int[]{100000}, 20),
            new TestDescription("findMinAbsNaNInf", this::findMinAbsNaNInf, 4, new int[]{100000}, 20),

            new TestDescription("findMinAndMax", this::findMinAndMax, 5, new int[]{100000}, 20),
            new TestDescription("findMinAndMax_array", this::findMinAndMax_array, 5, new int[]{100000}, 20),
            new TestDescription("findMinMat2", this::findMinMat2, 6, new int[]{25000}, 17),
            new TestDescription("findMinMat4", this::findMinMat4, 7, new int[]{10000}, 15),
            new TestDescription("fz", this::fz, 8, new int[]{100000}, 20),
            new TestDescription("fz_array", this::fz_array, 8, new int[]{100000}, 20),
            new TestDescription("fz2", this::fz2, 9, new int[]{225, 450}, 20, 5),
            new TestDescription("fz3", this::fz3, 10, new int[]{59, 48, 37}, 20, 7),
            new TestDescription("histogram", this::histogram, 11, new int[]{100000}, 20),
            new TestDescription("histogram_array", this::histogram_array, 11, new int[]{100000}, 20),
            // might want to add: new TestDescription("mode", this::mode, 12, new int[]{100000}, 20),
            new TestDescription("mode_array", this::mode_array, 12, new int[]{100000}, 20),
            new TestDescription("sumgcd", this::sumgcd, 13, new int[]{1 << 16}, 20)
    };

    private boolean runCorrectnessQuick(RenderScript RS, ScriptC_reduce s) {
        boolean pass = true;

        for (TestDescription td : correctnessTests) {
            pass &= run(td, RS, s, maxSeedsPerTest * td.seed, td.defSize);
        }

        return pass;
    }

    // NOTE: Each test execution gets maxSeedsPerTest, and there are
    // up to 3 + 5*log2MaxSize test executions in the full (as opposed
    // to quick) correctness run of a particular test description, and
    // we need an additional seed for pseudorandom size generation.
    // Assuming log2MaxSize does not exceed 32, then it should be
    // sufficient to reserve 1 + (3+5*32)*maxSeedsPerTest seeds per
    // TestDescription.
    //
    // See runCorrectness1D().
    private static final int seedsPerTestDescriptionCorrectness1D = 1 + (3 + 5 * 32) * maxSeedsPerTest;

    // NOTE: Each test execution gets maxSeedsPerTest, and there are
    // about 11*((log2MaxSize+1)**2) test executions in the full (as
    // opposed to quick) correctness run of a particular test
    // description, and we need a seed for pseudorandom size
    // generation.  Assuming log2MaxSize does not exceed 32, then it
    // should be sufficient to reserve 1 + 11*1089*maxSeedsPerTest
    // seeds per TestDescription.
    //
    // See runCorrectness2D().
    private static final int seedsPerTestDescriptionCorrectness2D = 1 + (11 * 1089) * maxSeedsPerTest;

    // NOTE: Each test execution gets maxSeedsPerTest, and there are
    // about 27*((log2MaxSize+1)**3) + 6*((log2MaxSize+1)**2) test
    // executions in the full (as opposed to quick) correctness run of
    // a particular test description, and we need a seed for (c).
    // Assuming log2MaxSize does not exceed 32, then it should
    // be sufficient to reserve 1 + (27*(33**3) + 6*(33**2))*maxSeedsPerTest
    // seeds per TestDescription, which can be simplified upwards to
    // 1 + (28*(33**3))*maxSeedsPerTest seeds per TestDescription.
    private static final int seedsPerTestDescriptionCorrectness3D = 1 + (28 * 35937) * maxSeedsPerTest;

    // Each test execution gets a certain number of seeds, and a full
    // (as opposed to quick) correctness run of a particular
    // TestDescription consists of some number of executions (each of
    // which needs up to maxSeedsPerTest) and may require some
    // additional seeds.
    private static final int seedsPerTestDescriptionCorrectness =
            Math.max(seedsPerTestDescriptionCorrectness1D,
                    Math.max(seedsPerTestDescriptionCorrectness2D,
                            seedsPerTestDescriptionCorrectness3D));

    private boolean runCorrectness(RenderScript RS, ScriptC_reduce s) {
        boolean pass = true;

        for (TestDescription td : correctnessTests) {
            switch (td.defSize.length) {
                case 1:
                    pass &= runCorrectness1D(td, RS, s);
                    break;
                case 2:
                    pass &= runCorrectness2D(td, RS, s);
                    break;
                case 3:
                    pass &= runCorrectness3D(td, RS, s);
                    break;
                default:
                    assertTrue("unexpected defSize.length " + td.defSize.length, false);
                    pass &= false;
                    break;
            }
        }

        return pass;
    }

    private boolean runCorrectness1D(TestDescription td, RenderScript RS, ScriptC_reduce s) {
        assertEquals(1, td.sparseness);
        final int log2MaxSize = td.log2MaxSize;
        assertTrue(log2MaxSize >= 0);

        boolean pass = true;

        // We will execute the test with the following sizes:
        // (a) Each power of 2 from zero (2**0) up to log2MaxSize (2**log2MaxSize)
        // (b) Each size from (a) +/-1
        // (c) 2 random sizes between each pair of adjacent points in (a)
        int[] testSizes = new int[
            /* a */ (1 + log2MaxSize) +
            /* b */ 2 * (1 + log2MaxSize) +
            /* c */ 2 * log2MaxSize];
        // See seedsPerTestDescriptionCorrectness1D

        final int seedForPickingTestSizes = td.seed * seedsPerTestDescriptionCorrectness;

        int nextTestIdx = 0;

        // Fill in (a) and (b)
        for (int i = 0; i <= log2MaxSize; ++i) {
            final int pwrOf2 = 1 << i;
            testSizes[nextTestIdx++] = pwrOf2;      /* a */
            testSizes[nextTestIdx++] = pwrOf2 - 1;  /* b */
            testSizes[nextTestIdx++] = pwrOf2 + 1;  /* b */
        }

        // Fill in (c)
        Random r = new Random(seedForPickingTestSizes);
        for (int i = 0; i < log2MaxSize; ++i) {
            final int lo = (1 << i) + 1;
            final int hi = 1 << (i + 1);

            if (lo < hi) {
                for (int j = 0; j < 2; ++j) {
                    testSizes[nextTestIdx++] = r.nextInt(hi - lo) + lo;
                }
            }
        }

        Arrays.sort(testSizes);

        int[] lastTestSizeArg = new int[]{-1};
        for (int i = 0; i < testSizes.length; ++i) {
            if ((testSizes[i] > 0) && (testSizes[i] != lastTestSizeArg[0])) {
                lastTestSizeArg[0] = testSizes[i];
                final int seedForTestExecution = seedForPickingTestSizes + 1 + i * maxSeedsPerTest;
                pass &= run(td, RS, s, seedForTestExecution, lastTestSizeArg);
            }
        }

        return pass;
    }

    private boolean runCorrectness2D(TestDescription td, RenderScript RS, ScriptC_reduce s) {
        final int log2MaxSize = td.log2MaxSize, maxSize = 1 << log2MaxSize, sparseness = td.sparseness;
        assertTrue((log2MaxSize >= 0) && (sparseness >= 1));

        boolean pass = true;

        final int[] sizePoints = computeSizePoints(log2MaxSize, sparseness);

        // We will execute the test with the following sizes:
        // (a) Each dimension at a power of 2 from sizePoints[]
        ///    such that the sum of the exponents does not exceed
        //     log2MaxSize
        // (b) Each size from (a) with one or both dimensions +/-1,
        //     except where this would exceed 2**log2MaxSize
        // (c) Approximately 2*(sizePoints.length**2) random sizes
        ArrayList<int[]> testSizesList = new ArrayList<int[]>();
        // See seedsPerTestDescriptionCorrectness2D

        final int seedForPickingTestSizes = td.seed * seedsPerTestDescriptionCorrectness;

        // Fill in (a) and (b)
        for (int i : sizePoints) {
            final int iPwrOf2 = 1 << i;
            for (int iDelta = -1; iDelta <= 1; ++iDelta) {
                final int iSize = iPwrOf2 + iDelta;
                for (int j : sizePoints) {
                    final int jPwrOf2 = 1 << j;
                    for (int jDelta = -1; jDelta <= 1; ++jDelta) {
                        final int jSize = jPwrOf2 + jDelta;
                        if ((long) iSize * (long) jSize <= maxSize)
                            testSizesList.add(new int[]{iSize, jSize});
                    }
                }
            }
        }

        // Fill in (c)
        Random r = new Random(seedForPickingTestSizes);
        for (int i : sizePoints) {
            for (int j : sizePoints) {
                final int size0 = 1 + r.nextInt(1 << i);
                final int size1 = 1 + r.nextInt(maxSize / size0);

                testSizesList.add(new int[]{size0, size1});
                testSizesList.add(new int[]{size1, size0});
            }
        }

        int[][] testSizes = testSizesList.toArray(new int[0][]);
        Arrays.sort(testSizes,
                (a, b) -> {
                    final int comp0 = ((Integer) a[0]).compareTo(b[0]);
                    return (comp0 != 0 ? comp0 : ((Integer) a[1]).compareTo(b[1]));
                });

        int[] lastTestSizeArg = null;
        for (int i = 0; i < testSizes.length; ++i) {
            if ((testSizes[i][0] <= 0) || (testSizes[i][1] <= 0))
                continue;
            if ((lastTestSizeArg != null) &&
                    (testSizes[i][0] == lastTestSizeArg[0]) &&
                    (testSizes[i][1] == lastTestSizeArg[1]))
                continue;
            lastTestSizeArg = testSizes[i];
            final int seedForTestExecution = seedForPickingTestSizes + 1 + i * maxSeedsPerTest;
            pass &= run(td, RS, s, seedForTestExecution, lastTestSizeArg);
        }

        return pass;
    }

    private boolean runCorrectness3D(TestDescription td, RenderScript RS, ScriptC_reduce s) {
        final int log2MaxSize = td.log2MaxSize, maxSize = 1 << log2MaxSize, sparseness = td.sparseness;
        assertTrue((log2MaxSize >= 0) && (sparseness >= 1));

        boolean pass = true;

        final int[] sizePoints = computeSizePoints(log2MaxSize, sparseness);

        // We will execute the test with the following sizes:
        // (a) Each dimension at a power of 2 from sizePoints[]
        ///    such that the sum of the exponents does not exceed
        //     log2MaxSize
        // (b) Each size from (a) with one or both dimensions +/-1,
        //     except where this would exceed 2**log2MaxSize
        // (c) Approximately 6*(sizePoints.length**2) random sizes
        ArrayList<int[]> testSizesList = new ArrayList<int[]>();
        // See seedsPerTestDescriptionCorrectness3D

        final int seedForPickingTestSizes = td.seed * seedsPerTestDescriptionCorrectness;

        // Fill in (a) and (b)
        for (int i : sizePoints) {
            final int iPwrOf2 = 1 << i;
            for (int iDelta = -1; iDelta <= 1; ++iDelta) {
                final int iSize = iPwrOf2 + iDelta;
                for (int j : sizePoints) {
                    final int jPwrOf2 = 1 << j;
                    for (int jDelta = -1; jDelta <= 1; ++jDelta) {
                        final int jSize = jPwrOf2 + jDelta;
                        for (int k : sizePoints) {
                            final int kPwrOf2 = 1 << k;
                            for (int kDelta = -1; kDelta <= 1; ++kDelta) {
                                final int kSize = kPwrOf2 + kDelta;
                                if ((long) iSize * (long) jSize * (long) kSize <= maxSize)
                                    testSizesList.add(new int[]{iSize, jSize, kSize});
                            }
                        }
                    }
                }
            }
        }

        // Fill in (c)
        Random r = new Random(seedForPickingTestSizes);
        for (int i : sizePoints) {
            for (int j : sizePoints) {
                final int size0 = 1 + r.nextInt(1 << i);
                final int size1 = 1 + r.nextInt(Math.min(1 << j, maxSize / size0));
                final int size2 = 1 + r.nextInt(maxSize / (size0 * size1));

                testSizesList.add(new int[]{size0, size1, size2});
                testSizesList.add(new int[]{size0, size2, size1});
                testSizesList.add(new int[]{size1, size0, size2});
                testSizesList.add(new int[]{size1, size2, size0});
                testSizesList.add(new int[]{size2, size0, size1});
                testSizesList.add(new int[]{size2, size1, size0});
            }
        }

        int[][] testSizes = testSizesList.toArray(new int[0][]);
        Arrays.sort(testSizes,
                (a, b) -> {
                    int comp = ((Integer) a[0]).compareTo(b[0]);
                    if (comp == 0)
                        comp = ((Integer) a[1]).compareTo(b[1]);
                    if (comp == 0)
                        comp = ((Integer) a[2]).compareTo(b[2]);
                    return comp;
                });

        int[] lastTestSizeArg = null;
        for (int i = 0; i < testSizes.length; ++i) {
            if ((testSizes[i][0] <= 0) || (testSizes[i][1] <= 0) || (testSizes[i][2] <= 0))
                continue;
            if ((lastTestSizeArg != null) &&
                    (testSizes[i][0] == lastTestSizeArg[0]) &&
                    (testSizes[i][1] == lastTestSizeArg[1]) &&
                    (testSizes[i][2] == lastTestSizeArg[2]))
                continue;

            // Apply Z-dimension limiting.
            //
            // The Z dimension is always handled specially by GPU
            // drivers, and a high value for this dimension can have
            // serious performance implications.  For example, Cuda
            // and OpenCL encourage Z to be the smallest dimension.
            if (testSizes[i][2] > 1024)
                continue;

            lastTestSizeArg = testSizes[i];
            final int seedForTestExecution = seedForPickingTestSizes + 1 + i * maxSeedsPerTest;
            pass &= run(td, RS, s, seedForTestExecution, lastTestSizeArg);
        }

        return pass;
    }

    private final TestDescription[] performanceTests = {
            new TestDescription("addint1D", this::addint1D, 0, new int[]{100000 << 10}),
            new TestDescription("addint2D", this::addint2D, 1, new int[]{450 << 5, 225 << 5}),
            new TestDescription("addint3D", this::addint3D, 2, new int[]{37 << 3, 48 << 3, 49 << 3}),
            new TestDescription("findMinAndMax", this::findMinAndMax, 3, new int[]{100000 << 9}),
            new TestDescription("fz", this::fz, 4, new int[]{100000 << 10}),
            new TestDescription("fz2", this::fz2, 5, new int[]{225 << 5, 450 << 5}),
            new TestDescription("fz3", this::fz3, 6, new int[]{59 << 3, 48 << 3, 37 << 3}),
            new TestDescription("histogram", this::histogram, 7, new int[]{100000 << 10}),
            // might want to add: new TestDescription("mode", this::mode, 8, new int[]{100000}),
            new TestDescription("sumgcd", this::sumgcd, 9, new int[]{1 << 21})
    };

    private boolean runPerformanceQuick(RenderScript RS, ScriptC_reduce s) {
        boolean pass = true;

        for (TestDescription td : performanceTests) {
            pass &= run(td, RS, s, maxSeedsPerTest * td.seed, td.defSize);
        }

        return pass;
    }

    private boolean runCorrectnessPatterns(RenderScript RS, ScriptC_reduce s) {
        // Test some very specific usage patterns.
        boolean pass = true;

        pass &= patternDuplicateAnonymousResult(RS, s);
        pass &= patternFindMinAndMaxInf(RS, s);
        pass &= patternInterleavedReduce(RS, s);
        pass &= patternRedundantGet(RS, s);

        return pass;
    }

    public void run() {
        RenderScript pRS = RenderScript.create(mCtx);
        ScriptC_reduce s = new ScriptC_reduce(pRS);
        s.set_negInf(Float.NEGATIVE_INFINITY);
        s.set_posInf(Float.POSITIVE_INFINITY);

        boolean pass = true;

        pass &= runCorrectnessPatterns(pRS, s);
        pass &= runCorrectnessQuick(pRS, s);
        pass &= runCorrectness(pRS, s);
        // pass &= runPerformanceQuick(pRS, s);

        pRS.finish();
        s.destroy();
        pRS.destroy();

        Log.i(TAG, pass ? "PASSED" : "FAILED");
        if (pass)
            passTest();
        else
            failTest();
    }
}

// TODO: Add machinery for easily running fuller (i.e., non-sparse) testing.