diff --git a/.github/workflows/gpuTests.yml b/.github/workflows/gpuTests.yml new file mode 100644 index 00000000000..99eaaa58b65 --- /dev/null +++ b/.github/workflows/gpuTests.yml @@ -0,0 +1,22 @@ +name: gpu tests + +on: + push: + branches: + - main-gpu + pull_request: + branches: + - main-gpu + workflow_dispatch: + +jobs: + test: + name: gpu ubuntu instance + runs-on: [self-hosted, linux, x64, gpu] + + steps: + - name: Checkout Repository + uses: actions/checkout@v2 + + - name: print hello + run: printf "Hello GPU!" diff --git a/pom.xml b/pom.xml index d3234589d51..8a8eebc40fa 100644 --- a/pom.xml +++ b/pom.xml @@ -53,6 +53,9 @@ 1.8 Testing settings true + classes + 2 + 1C 2 true ** @@ -294,9 +297,10 @@ 3.0.0-M5 ${maven.test.skip} - classes - 2 - 1C + ${test-parallel} + ${test-threadCount} + + ${test-forkCount} false brief true diff --git a/src/test/java/org/apache/sysds/test/AutomatedTestBase.java b/src/test/java/org/apache/sysds/test/AutomatedTestBase.java index 6b21cd62224..41ba0f57acb 100644 --- a/src/test/java/org/apache/sysds/test/AutomatedTestBase.java +++ b/src/test/java/org/apache/sysds/test/AutomatedTestBase.java @@ -1522,8 +1522,10 @@ else if(rtplatform == ExecMode.SPARK) if(TEST_GPU) args.add("-gpu"); - if(VERBOSE_STATS) + if(VERBOSE_STATS) { args.add("-stats"); + args.add("100"); + } } public static int getRandomAvailablePort() { diff --git a/src/test/java/org/apache/sysds/test/functions/dnn/Conv2DTest.java b/src/test/java/org/apache/sysds/test/functions/dnn/Conv2DTest.java index 5921e449069..176ad875712 100644 --- a/src/test/java/org/apache/sysds/test/functions/dnn/Conv2DTest.java +++ b/src/test/java/org/apache/sysds/test/functions/dnn/Conv2DTest.java @@ -269,7 +269,7 @@ public void runConv2DTest( ExecType et, int imgSize, int numImg, int numChannels String RI_HOME = SCRIPT_DIR + TEST_DIR; fullDMLScriptName = RI_HOME + TEST_NAME + ".dml"; - programArgs = new String[] {"recompile_runtime", "-args", + programArgs = new String[] {"-explain", "recompile_runtime", "-args", String.valueOf(imgSize), String.valueOf(numImg), String.valueOf(numChannels), String.valueOf(numFilters), String.valueOf(filterSize), String.valueOf(stride), String.valueOf(pad), diff --git a/src/test/java/org/apache/sysds/test/gpu/BuiltinUnaryGPUInstructionTest.java b/src/test/java/org/apache/sysds/test/gpu/BuiltinUnaryGPUInstructionTest.java new file mode 100644 index 00000000000..9dff8272fc8 --- /dev/null +++ b/src/test/java/org/apache/sysds/test/gpu/BuiltinUnaryGPUInstructionTest.java @@ -0,0 +1,333 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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. + */ + +package org.apache.sysds.test.gpu; + +import org.apache.sysds.test.AutomatedTestBase; +import org.apache.sysds.test.functions.builtin.BuiltinSigmoidTest; +import org.apache.sysds.test.functions.unary.matrix.ACosTest; +import org.apache.sysds.test.functions.unary.matrix.ASinTest; +import org.apache.sysds.test.functions.unary.matrix.ATanTest; +import org.apache.sysds.test.functions.unary.matrix.AbsTest; +import org.apache.sysds.test.functions.unary.matrix.CosTest; +import org.apache.sysds.test.functions.unary.matrix.FullCummaxTest; +import org.apache.sysds.test.functions.unary.matrix.FullCumminTest; +import org.apache.sysds.test.functions.unary.matrix.FullCumprodTest; +import org.apache.sysds.test.functions.unary.matrix.FullCumsumTest; +import org.apache.sysds.test.functions.unary.matrix.FullCumsumprodTest; +import org.apache.sysds.test.functions.unary.matrix.FullSignTest; +import org.apache.sysds.test.functions.unary.matrix.RoundTest; +import org.apache.sysds.test.functions.unary.matrix.SinTest; +import org.apache.sysds.test.functions.unary.matrix.SqrtTest; +import org.apache.sysds.test.functions.unary.matrix.TanTest; +import org.junit.Assert; +import org.junit.Test; + +public class BuiltinUnaryGPUInstructionTest extends AutomatedTestBase { + @Override public void setUp() { + TEST_GPU = true; + VERBOSE_STATS = true; + } + + // ToDo: + // @Test public void ExponentTest() {} + // @Test public void LogarithmTest() {} + // @Test public void SoftmaxTest() {} + // @Test public void CoshTest() {} + // @Test public void SinhTest() {} + // @Test public void TanhTest() {} + + @Test public void AbsTest() { + AbsTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.AbsTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testPositive(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_abs")); + dmlTestCase.testNegative(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_abs")); + dmlTestCase.testRandom(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_abs")); + } + + @Test public void ACosTest() { + ACosTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.ACosTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testPositive(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_acos")); + dmlTestCase.testNegative(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_acos")); + dmlTestCase.testRandom(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_acos")); + } + + @Test public void ASinTest() { + ASinTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.ASinTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testPositive(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_asin")); + dmlTestCase.testNegative(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_asin")); + dmlTestCase.testRandom(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_asin")); + } + + @Test public void ATanTest() { + ATanTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.ATanTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testPositive(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_atan")); + dmlTestCase.testNegative(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_atan")); + dmlTestCase.testRandom(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_atan")); + } + + @Test public void CeilTest() { + RoundTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.RoundTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testCeil1(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ceil")); + dmlTestCase.testCeil2(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ceil")); + dmlTestCase.testCeil3(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ceil")); + dmlTestCase.testCeil4(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ceil")); + dmlTestCase.testCeil5(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ceil")); + dmlTestCase.testCeil6(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ceil")); + } + + @Test public void CosTest() { + CosTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.CosTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testPositive(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_cos")); + dmlTestCase.testNegative(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_cos")); + dmlTestCase.testRandom(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_cos")); + } + + @Test public void CummaxTest() { + FullCummaxTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.FullCummaxTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testCummaxColVectorDenseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucummax")); + dmlTestCase.testCummaxColVectorSparseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucummax")); + dmlTestCase.testCummaxMatrixDenseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucummax")); + dmlTestCase.testCummaxMatrixSparseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucummax")); + dmlTestCase.testCummaxRowVectorDenseCP(); + Assert.assertFalse(heavyHittersContainsSubString("gpu_ucummax")); + dmlTestCase.testCummaxRowVectorDenseNoRewritesCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucummax")); + dmlTestCase.testCummaxRowVectorSparseCP(); + Assert.assertFalse(heavyHittersContainsSubString("gpu_ucummax")); + dmlTestCase.testCummaxRowVectorSparseNoRewritesCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucummax")); + } + + @Test public void CumminTest() { + FullCumminTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.FullCumminTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testCumminColVectorDenseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucummin")); + dmlTestCase.testCumminColVectorSparseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucummin")); + dmlTestCase.testCumminMatrixDenseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucummin")); + dmlTestCase.testCumminMatrixSparseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucummin")); + dmlTestCase.testCumminRowVectorDenseCP(); + Assert.assertFalse(heavyHittersContainsSubString("gpu_ucummin")); + dmlTestCase.testCumminRowVectorDenseNoRewritesCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucummin")); + dmlTestCase.testCumminRowVectorSparseCP(); + Assert.assertFalse(heavyHittersContainsSubString("gpu_ucummin")); + dmlTestCase.testCumminRowVectorSparseNoRewritesCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucummin")); + } + + @Test public void CumprodTest() { + FullCumprodTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.FullCumprodTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testCumprodColVectorDenseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucum*")); + dmlTestCase.testCumprodColVectorSparseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucum*")); + dmlTestCase.testCumprodMatrixDenseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucum*")); + dmlTestCase.testCumprodMatrixSparseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucum*")); + dmlTestCase.testCumprodRowVectorDenseCP(); + Assert.assertFalse(heavyHittersContainsSubString("gpu_ucum*")); + dmlTestCase.testCumprodRowVectorDenseNoRewritesCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucum*")); + dmlTestCase.testCumprodRowVectorSparseCP(); + Assert.assertFalse(heavyHittersContainsSubString("gpu_ucum*")); + dmlTestCase.testCumprodRowVectorSparseNoRewritesCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucum*")); + } + + @Test public void CumsumTest() { + FullCumsumTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.FullCumsumTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testCumsumColVectorDenseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucumk+")); + dmlTestCase.testCumsumColVectorSparseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucumk+")); + dmlTestCase.testCumsumMatrixDenseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucumk+")); + dmlTestCase.testCumsumMatrixSparseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucumk+")); + dmlTestCase.testCumsumRowVectorDenseCP(); + Assert.assertFalse(heavyHittersContainsSubString("gpu_ucumk+")); + dmlTestCase.testCumsumRowVectorDenseNoRewritesCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucumk+")); + dmlTestCase.testCumsumRowVectorSparseCP(); + Assert.assertFalse(heavyHittersContainsSubString("gpu_ucumk+")); + dmlTestCase.testCumsumRowVectorSparseNoRewritesCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucumk+")); + } + + @Test public void CumsumprodTest() { + FullCumsumprodTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.FullCumsumprodTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testCumsumprodBackwardDenseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucumk+*")); + dmlTestCase.testCumsumprodBackwardSparseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucumk+*")); + dmlTestCase.testCumsumprodForwardDenseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucumk+*")); + dmlTestCase.testCumsumprodForwardSparseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_ucumk+*")); + } + + @Test public void FloorTest() { + RoundTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.RoundTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testFloor1(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_floor")); + dmlTestCase.testFloor2(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_floor")); + dmlTestCase.testFloor3(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_floor")); + dmlTestCase.testFloor4(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_floor")); + dmlTestCase.testFloor5(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_floor")); + dmlTestCase.testFloor6(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_floor")); + } + + @Test public void RoundTest() { + RoundTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.RoundTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testRound1(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_round")); + dmlTestCase.testRound2(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_round")); + dmlTestCase.testRound3(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_round")); + dmlTestCase.testRound4(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_round")); + dmlTestCase.testRound5(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_round")); + dmlTestCase.testRound6(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_round")); + } + + @Test public void SinTest() { + SinTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.SinTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testPositive(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_sin")); + dmlTestCase.testNegative(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_sin")); + dmlTestCase.testRandom(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_sin")); + } + + @Test public void SqrtTest() { + SqrtTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.SqrtTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testPositive(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_sqrt")); + dmlTestCase.testNegativeMatrix(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_sqrt")); + dmlTestCase.testNegativeVector(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_sqrt")); + } + + @Test public void SignTest() { + FullSignTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.FullSignTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testRewriteSignDenseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_sign")); + dmlTestCase.testRewriteSignSparseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_sign")); + dmlTestCase.testSignDenseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_sign")); + dmlTestCase.testSignSparseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_sign")); + } + + @Test public void SigmoidTest() { + BuiltinSigmoidTest dmlTestCase = new org.apache.sysds.test.functions.builtin.BuiltinSigmoidTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testSigmoidMatrixDenseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_sigmoid")); + dmlTestCase.testSigmoidMatrixSparseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_sigmoid")); + dmlTestCase.testSigmoidScalarDenseCP(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_sigmoid")); + } + + @Test public void TanTest() { + TanTest dmlTestCase = new org.apache.sysds.test.functions.unary.matrix.TanTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + dmlTestCase.testPositive(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_tan")); + dmlTestCase.testNegative(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_tan")); + dmlTestCase.testRandom(); + Assert.assertTrue(heavyHittersContainsSubString("gpu_tan")); + } +} diff --git a/src/test/java/org/apache/sysds/test/gpu/codegen/CellwiseTmplTest.java b/src/test/java/org/apache/sysds/test/gpu/codegen/CellwiseTmplTest.java new file mode 100644 index 00000000000..c0a1113f19e --- /dev/null +++ b/src/test/java/org/apache/sysds/test/gpu/codegen/CellwiseTmplTest.java @@ -0,0 +1,90 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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. + */ + +package org.apache.sysds.test.gpu.codegen; + +import org.apache.sysds.test.AutomatedTestBase; +import org.junit.Test; + +public class CellwiseTmplTest extends AutomatedTestBase { + org.apache.sysds.test.functions.codegen.CellwiseTmplTest dmlTestCase; + + @Override public void setUp() { + TEST_GPU = true; + dmlTestCase = new org.apache.sysds.test.functions.codegen.CellwiseTmplTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + } + + @Test public void testCodegenCellwise1() { dmlTestCase.testCodegenCellwise1(); } + @Test public void testCodegenCellwise2() { dmlTestCase.testCodegenCellwise2(); } + @Test public void testCodegenCellwise3() { dmlTestCase.testCodegenCellwise3(); } + @Test public void testCodegenCellwise4() { dmlTestCase.testCodegenCellwise4(); } + @Test public void testCodegenCellwise5() { dmlTestCase.testCodegenCellwise5(); } + @Test public void testCodegenCellwise6() { dmlTestCase.testCodegenCellwise6(); } + @Test public void testCodegenCellwise7() { dmlTestCase.testCodegenCellwise7(); } + @Test public void testCodegenCellwise8() { dmlTestCase.testCodegenCellwise8(); } + @Test public void testCodegenCellwise9() { dmlTestCase.testCodegenCellwise9(); } + @Test public void testCodegenCellwise10() { dmlTestCase.testCodegenCellwise10(); } + @Test public void testCodegenCellwise11() { dmlTestCase.testCodegenCellwise11(); } + @Test public void testCodegenCellwise12() { dmlTestCase.testCodegenCellwise12(); } + @Test public void testCodegenCellwise13() { dmlTestCase.testCodegenCellwise13(); } + @Test public void testCodegenCellwise14() { dmlTestCase.testCodegenCellwise14(); } + @Test public void testCodegenCellwise15() { dmlTestCase.testCodegenCellwise15(); } + @Test public void testCodegenCellwise16() { dmlTestCase.testCodegenCellwise16(); } + @Test public void testCodegenCellwise17() { dmlTestCase.testCodegenCellwise17(); } + @Test public void testCodegenCellwise18() { dmlTestCase.testCodegenCellwise18(); } + @Test public void testCodegenCellwise19() { dmlTestCase.testCodegenCellwise19(); } + @Test public void testCodegenCellwise20() { dmlTestCase.testCodegenCellwise20(); } + @Test public void testCodegenCellwise21() { dmlTestCase.testCodegenCellwise21(); } + @Test public void testCodegenCellwise22() { dmlTestCase.testCodegenCellwise22(); } + @Test public void testCodegenCellwise23() { dmlTestCase.testCodegenCellwise23(); } + @Test public void testCodegenCellwise24() { dmlTestCase.testCodegenCellwise24(); } + @Test public void testCodegenCellwise25() { dmlTestCase.testCodegenCellwise25(); } + @Test public void testCodegenCellwise26() { dmlTestCase.testCodegenCellwise26(); } + @Test public void testCodegenCellwise27() { dmlTestCase.testCodegenCellwise27(); } + + @Test public void testCodegenCellwiseRewrite1() { dmlTestCase.testCodegenCellwiseRewrite1(); } + @Test public void testCodegenCellwiseRewrite2() { dmlTestCase.testCodegenCellwiseRewrite2(); } + @Test public void testCodegenCellwiseRewrite3() { dmlTestCase.testCodegenCellwiseRewrite3(); } + @Test public void testCodegenCellwiseRewrite4() { dmlTestCase.testCodegenCellwiseRewrite4(); } + @Test public void testCodegenCellwiseRewrite5() { dmlTestCase.testCodegenCellwiseRewrite5(); } + @Test public void testCodegenCellwiseRewrite6() { dmlTestCase.testCodegenCellwiseRewrite6(); } + @Test public void testCodegenCellwiseRewrite7() { dmlTestCase.testCodegenCellwiseRewrite7(); } + @Test public void testCodegenCellwiseRewrite8() { dmlTestCase.testCodegenCellwiseRewrite8(); } + @Test public void testCodegenCellwiseRewrite9() { dmlTestCase.testCodegenCellwiseRewrite9(); } + @Test public void testCodegenCellwiseRewrite10() { dmlTestCase.testCodegenCellwiseRewrite10(); } + @Test public void testCodegenCellwiseRewrite11() { dmlTestCase.testCodegenCellwiseRewrite11(); } + @Test public void testCodegenCellwiseRewrite12() { dmlTestCase.testCodegenCellwiseRewrite12(); } + @Test public void testCodegenCellwiseRewrite13() { dmlTestCase.testCodegenCellwiseRewrite13(); } + @Test public void testCodegenCellwiseRewrite14() { dmlTestCase.testCodegenCellwiseRewrite14(); } + @Test public void testCodegenCellwiseRewrite15() { dmlTestCase.testCodegenCellwiseRewrite15(); } + @Test public void testCodegenCellwiseRewrite16() { dmlTestCase.testCodegenCellwiseRewrite16(); } + @Test public void testCodegenCellwiseRewrite17() { dmlTestCase.testCodegenCellwiseRewrite17(); } + @Test public void testCodegenCellwiseRewrite18() { dmlTestCase.testCodegenCellwiseRewrite18(); } + @Test public void testCodegenCellwiseRewrite19() { dmlTestCase.testCodegenCellwiseRewrite19(); } + @Test public void testCodegenCellwiseRewrite20() { dmlTestCase.testCodegenCellwiseRewrite20(); } + @Test public void testCodegenCellwiseRewrite21() { dmlTestCase.testCodegenCellwiseRewrite21(); } + @Test public void testCodegenCellwiseRewrite22() { dmlTestCase.testCodegenCellwiseRewrite22(); } + @Test public void testCodegenCellwiseRewrite23() { dmlTestCase.testCodegenCellwiseRewrite23(); } + @Test public void testCodegenCellwiseRewrite24() { dmlTestCase.testCodegenCellwiseRewrite24(); } + @Test public void testCodegenCellwiseRewrite25() { dmlTestCase.testCodegenCellwiseRewrite25(); } + @Test public void testCodegenCellwiseRewrite26() { dmlTestCase.testCodegenCellwiseRewrite26(); } + @Test public void testCodegenCellwiseRewrite27() { dmlTestCase.testCodegenCellwiseRewrite27(); } +} diff --git a/src/test/java/org/apache/sysds/test/gpu/codegen/RowAggTmplTest.java b/src/test/java/org/apache/sysds/test/gpu/codegen/RowAggTmplTest.java new file mode 100644 index 00000000000..f44d9caebe5 --- /dev/null +++ b/src/test/java/org/apache/sysds/test/gpu/codegen/RowAggTmplTest.java @@ -0,0 +1,129 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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. + */ + +package org.apache.sysds.test.gpu.codegen; + +import org.apache.sysds.test.AutomatedTestBase; +import org.junit.Test; + +public class RowAggTmplTest extends AutomatedTestBase { + org.apache.sysds.test.functions.codegen.RowAggTmplTest dmlTestCase; + + @Override public void setUp() { + TEST_GPU = true; + dmlTestCase = new org.apache.sysds.test.functions.codegen.RowAggTmplTest(); + dmlTestCase.setUpBase(); + dmlTestCase.setUp(); + } + + @Test public void testCodegenRowAgg1CP() { dmlTestCase.testCodegenRowAgg1CP(); } + @Test public void testCodegenRowAgg2CP() { dmlTestCase.testCodegenRowAgg2CP(); } + @Test public void testCodegenRowAgg3CP() { dmlTestCase.testCodegenRowAgg3CP(); } + @Test public void testCodegenRowAgg4CP() { dmlTestCase.testCodegenRowAgg4CP(); } + @Test public void testCodegenRowAgg5CP() { dmlTestCase.testCodegenRowAgg5CP(); } + @Test public void testCodegenRowAgg6CP() { dmlTestCase.testCodegenRowAgg6CP(); } + @Test public void testCodegenRowAgg7CP() { dmlTestCase.testCodegenRowAgg7CP(); } + @Test public void testCodegenRowAgg8CP() { dmlTestCase.testCodegenRowAgg8CP(); } + @Test public void testCodegenRowAgg9CP() { dmlTestCase.testCodegenRowAgg9CP(); } + @Test public void testCodegenRowAgg10CP() { dmlTestCase.testCodegenRowAgg10CP(); } + @Test public void testCodegenRowAgg11CP() { dmlTestCase.testCodegenRowAgg11CP(); } + @Test public void testCodegenRowAgg12CP() { dmlTestCase.testCodegenRowAgg12CP(); } + @Test public void testCodegenRowAgg13CP() { dmlTestCase.testCodegenRowAgg13CP(); } + @Test public void testCodegenRowAgg14CP() { dmlTestCase.testCodegenRowAgg14CP(); } + @Test public void testCodegenRowAgg15CP() { dmlTestCase.testCodegenRowAgg15CP(); } + @Test public void testCodegenRowAgg16CP() { dmlTestCase.testCodegenRowAgg16CP(); } + @Test public void testCodegenRowAgg17CP() { dmlTestCase.testCodegenRowAgg17CP(); } + @Test public void testCodegenRowAgg18CP() { dmlTestCase.testCodegenRowAgg18CP(); } + @Test public void testCodegenRowAgg19CP() { dmlTestCase.testCodegenRowAgg19CP(); } + @Test public void testCodegenRowAgg20CP() { dmlTestCase.testCodegenRowAgg20CP(); } + @Test public void testCodegenRowAgg21CP() { dmlTestCase.testCodegenRowAgg21CP(); } + @Test public void testCodegenRowAgg22CP() { dmlTestCase.testCodegenRowAgg22CP(); } + @Test public void testCodegenRowAgg23CP() { dmlTestCase.testCodegenRowAgg23CP(); } + @Test public void testCodegenRowAgg24CP() { dmlTestCase.testCodegenRowAgg24CP(); } + @Test public void testCodegenRowAgg25CP() { dmlTestCase.testCodegenRowAgg25CP(); } + @Test public void testCodegenRowAgg26CP() { dmlTestCase.testCodegenRowAgg26CP(); } + @Test public void testCodegenRowAgg27CP() { dmlTestCase.testCodegenRowAgg27CP(); } + @Test public void testCodegenRowAgg28CP() { dmlTestCase.testCodegenRowAgg28CP(); } + @Test public void testCodegenRowAgg29CP() { dmlTestCase.testCodegenRowAgg29CP(); } + @Test public void testCodegenRowAgg30CP() { dmlTestCase.testCodegenRowAgg30CP(); } + @Test public void testCodegenRowAgg31CP() { dmlTestCase.testCodegenRowAgg31CP(); } + @Test public void testCodegenRowAgg32CP() { dmlTestCase.testCodegenRowAgg32CP(); } + @Test public void testCodegenRowAgg33CP() { dmlTestCase.testCodegenRowAgg33CP(); } + @Test public void testCodegenRowAgg34CP() { dmlTestCase.testCodegenRowAgg34CP(); } + @Test public void testCodegenRowAgg35CP() { dmlTestCase.testCodegenRowAgg35CP(); } + @Test public void testCodegenRowAgg36CP() { dmlTestCase.testCodegenRowAgg36CP(); } + @Test public void testCodegenRowAgg37CP() { dmlTestCase.testCodegenRowAgg37CP(); } + @Test public void testCodegenRowAgg38CP() { dmlTestCase.testCodegenRowAgg38CP(); } + @Test public void testCodegenRowAgg39CP() { dmlTestCase.testCodegenRowAgg39CP(); } + @Test public void testCodegenRowAgg40CP() { dmlTestCase.testCodegenRowAgg40CP(); } + @Test public void testCodegenRowAgg41CP() { dmlTestCase.testCodegenRowAgg41CP(); } + @Test public void testCodegenRowAgg42CP() { dmlTestCase.testCodegenRowAgg42CP(); } + @Test public void testCodegenRowAgg43CP() { dmlTestCase.testCodegenRowAgg43CP(); } + @Test public void testCodegenRowAgg44CP() { dmlTestCase.testCodegenRowAgg44CP(); } + @Test public void testCodegenRowAgg45CP() { dmlTestCase.testCodegenRowAgg45CP(); } + @Test public void testCodegenRowAgg46CP() { dmlTestCase.testCodegenRowAgg46CP(); } + + @Test public void testCodegenRowAggRewrite1CP() { dmlTestCase.testCodegenRowAggRewrite1CP(); } + @Test public void testCodegenRowAggRewrite2CP() { dmlTestCase.testCodegenRowAggRewrite2CP(); } + @Test public void testCodegenRowAggRewrite3CP() { dmlTestCase.testCodegenRowAggRewrite3CP(); } + @Test public void testCodegenRowAggRewrite4CP() { dmlTestCase.testCodegenRowAggRewrite4CP(); } + @Test public void testCodegenRowAggRewrite5CP() { dmlTestCase.testCodegenRowAggRewrite5CP(); } + @Test public void testCodegenRowAggRewrite6CP() { dmlTestCase.testCodegenRowAggRewrite6CP(); } + @Test public void testCodegenRowAggRewrite7CP() { dmlTestCase.testCodegenRowAggRewrite7CP(); } + @Test public void testCodegenRowAggRewrite8CP() { dmlTestCase.testCodegenRowAggRewrite8CP(); } + @Test public void testCodegenRowAggRewrite9CP() { dmlTestCase.testCodegenRowAggRewrite9CP(); } + @Test public void testCodegenRowAggRewrite10CP() { dmlTestCase.testCodegenRowAggRewrite10CP(); } + @Test public void testCodegenRowAggRewrite11CP() { dmlTestCase.testCodegenRowAggRewrite11CP(); } + @Test public void testCodegenRowAggRewrite12CP() { dmlTestCase.testCodegenRowAggRewrite12CP(); } + @Test public void testCodegenRowAggRewrite13CP() { dmlTestCase.testCodegenRowAggRewrite13CP(); } + @Test public void testCodegenRowAggRewrite14CP() { dmlTestCase.testCodegenRowAggRewrite14CP(); } + @Test public void testCodegenRowAggRewrite15CP() { dmlTestCase.testCodegenRowAggRewrite15CP(); } + @Test public void testCodegenRowAggRewrite16CP() { dmlTestCase.testCodegenRowAggRewrite16CP(); } + @Test public void testCodegenRowAggRewrite17CP() { dmlTestCase.testCodegenRowAggRewrite17CP(); } + @Test public void testCodegenRowAggRewrite18CP() { dmlTestCase.testCodegenRowAggRewrite18CP(); } + @Test public void testCodegenRowAggRewrite19CP() { dmlTestCase.testCodegenRowAggRewrite19CP(); } + @Test public void testCodegenRowAggRewrite20CP() { dmlTestCase.testCodegenRowAggRewrite20CP(); } + @Test public void testCodegenRowAggRewrite21CP() { dmlTestCase.testCodegenRowAggRewrite21CP(); } + @Test public void testCodegenRowAggRewrite22CP() { dmlTestCase.testCodegenRowAggRewrite22CP(); } + @Test public void testCodegenRowAggRewrite23CP() { dmlTestCase.testCodegenRowAggRewrite23CP(); } + @Test public void testCodegenRowAggRewrite24CP() { dmlTestCase.testCodegenRowAggRewrite24CP(); } + @Test public void testCodegenRowAggRewrite25CP() { dmlTestCase.testCodegenRowAggRewrite25CP(); } + @Test public void testCodegenRowAggRewrite26CP() { dmlTestCase.testCodegenRowAggRewrite26CP(); } + @Test public void testCodegenRowAggRewrite27CP() { dmlTestCase.testCodegenRowAggRewrite27CP(); } + @Test public void testCodegenRowAggRewrite28CP() { dmlTestCase.testCodegenRowAggRewrite28CP(); } + @Test public void testCodegenRowAggRewrite29CP() { dmlTestCase.testCodegenRowAggRewrite29CP(); } + @Test public void testCodegenRowAggRewrite30CP() { dmlTestCase.testCodegenRowAggRewrite30CP(); } + @Test public void testCodegenRowAggRewrite31CP() { dmlTestCase.testCodegenRowAggRewrite31CP(); } + @Test public void testCodegenRowAggRewrite32CP() { dmlTestCase.testCodegenRowAggRewrite32CP(); } + @Test public void testCodegenRowAggRewrite33CP() { dmlTestCase.testCodegenRowAggRewrite33CP(); } + @Test public void testCodegenRowAggRewrite34CP() { dmlTestCase.testCodegenRowAggRewrite34CP(); } + @Test public void testCodegenRowAggRewrite35CP() { dmlTestCase.testCodegenRowAggRewrite35CP(); } + @Test public void testCodegenRowAggRewrite36CP() { dmlTestCase.testCodegenRowAggRewrite36CP(); } + @Test public void testCodegenRowAggRewrite37CP() { dmlTestCase.testCodegenRowAggRewrite37CP(); } + @Test public void testCodegenRowAggRewrite38CP() { dmlTestCase.testCodegenRowAggRewrite38CP(); } + @Test public void testCodegenRowAggRewrite39CP() { dmlTestCase.testCodegenRowAggRewrite39CP(); } + @Test public void testCodegenRowAggRewrite40CP() { dmlTestCase.testCodegenRowAggRewrite40CP(); } + @Test public void testCodegenRowAggRewrite41CP() { dmlTestCase.testCodegenRowAggRewrite41CP(); } + @Test public void testCodegenRowAggRewrite42CP() { dmlTestCase.testCodegenRowAggRewrite42CP(); } + @Test public void testCodegenRowAggRewrite43CP() { dmlTestCase.testCodegenRowAggRewrite43CP(); } + @Test public void testCodegenRowAggRewrite44CP() { dmlTestCase.testCodegenRowAggRewrite44CP(); } + @Test public void testCodegenRowAggRewrite45CP() { dmlTestCase.testCodegenRowAggRewrite45CP(); } + @Test public void testCodegenRowAggRewrite46CP() { dmlTestCase.testCodegenRowAggRewrite46CP(); } + +}