derek.holloway
7502bf64a4
CodeQL / Analyze (actions) (push) Canceled after 0s
CodeQL / Analyze (python) (push) Canceled after 0s
pre-commit / pre-commit (push) Canceled after 0s
Multi-Arch CI / setup (push) Canceled after 0s
Publish build_manylinux_x86_64 images / publish_build_manylinux_x86_64 (push) Canceled after 0s
Setup (Multi-Arch) / setup (push) Canceled after 0s
Multi-Arch CI / Linux::${{ fromJSON(needs.setup.outputs.linux_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubi10 image / publish_no_rocm_image_ubi10 (push) Canceled after 0s
Multi-Arch CI / Windows::${{ fromJSON(needs.setup.outputs.windows_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Multi-Arch CI / Manifest Diff (push) Canceled after 0s
TheRock Manifest Diff Report / Generate Manifest Diff Report (push) Canceled after 0s
Multi-Arch CI / CI Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_ocl_rt images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_rocgdb images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Unit Tests / Unit Tests :: ubuntu-24.04 (push) Canceled after 0s
Unit Tests / Unit Tests :: windows-2022 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_media (push) Canceled after 0s
Unit Tests / Unit Tests Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_openmpi (push) Canceled after 0s
1395 lines
33 KiB
Python
1395 lines
33 KiB
Python
# ##########################################################################
|
|
# Copyright (C) 2022 Advanced Micro Devices, Inc. All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions
|
|
# are met:
|
|
#
|
|
# 1. Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
#
|
|
# 2. Redistributions in binary form must reproduce the above copyright
|
|
# notice, this list of conditions and the following disclaimer in the
|
|
# documentation and/or other materials provided with the distribution.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
# SUCH DAMAGE.
|
|
# ##########################################################################
|
|
|
|
import collections
|
|
import os
|
|
import re
|
|
import shlex
|
|
import unittest
|
|
from subprocess import Popen, PIPE
|
|
|
|
def call_rocsolver_bench(*args):
|
|
cmd = ['./rocsolver-bench']
|
|
for arg in args:
|
|
if isinstance(arg, str):
|
|
cmd.extend(shlex.split(arg, False, False))
|
|
elif isinstance(arg, collections.Sequence):
|
|
cmd.extend(arg)
|
|
else:
|
|
cmd.push(str(arg))
|
|
process = Popen(cmd, stdout=PIPE, stderr=PIPE)
|
|
stdout, stderr = process.communicate()
|
|
return (str(stdout, encoding='utf-8', errors='surrogateescape'),
|
|
str(stderr, encoding='utf-8', errors='surrogateescape'),
|
|
process.returncode)
|
|
|
|
class TestRocsolverBench(unittest.TestCase):
|
|
def parse_arguments(self, bench_output):
|
|
m = re.search(r"\n=+\nArguments:\s*\n=+\n(?P<arg_names>.*)\n(?P<arg_values>.*)\n",
|
|
bench_output, re.MULTILINE)
|
|
self.assertTrue(m)
|
|
arg_names = m.group('arg_names').split()
|
|
arg_values = m.group('arg_values').split()
|
|
self.assertEqual(len(arg_names), len(arg_values))
|
|
return dict(zip(arg_names, arg_values))
|
|
|
|
def parse_results(self, bench_output):
|
|
m = re.search(r"\n=+\nResults:\s*\n=+\n(?P<arg_names>.*)\n(?P<arg_values>.*)\n",
|
|
bench_output, re.MULTILINE)
|
|
self.assertTrue(m)
|
|
arg_names = m.group('arg_names').split()
|
|
arg_values = m.group('arg_values').split()
|
|
self.assertEqual(len(arg_names), len(arg_values))
|
|
return dict(zip(arg_names, arg_values))
|
|
|
|
def test_help(self):
|
|
out, err, exitcode = call_rocsolver_bench('--help')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
self.assertNotEqual(out, '')
|
|
|
|
def test_validate_precision(self):
|
|
for precision in 'sdcz':
|
|
with self.subTest(precision=precision):
|
|
out, err, exitcode = call_rocsolver_bench(f'-f gels -r {precision} -n 10 -m 15')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
|
|
out, err, exitcode = call_rocsolver_bench('-f gels -r 0 -n 10 -m 15')
|
|
self.assertNotEqual(err, '')
|
|
self.assertNotEqual(exitcode, 0)
|
|
|
|
def test_validate_operation(self):
|
|
for trans in 'NTC':
|
|
with self.subTest(trans=trans):
|
|
out, err, exitcode = call_rocsolver_bench(f'-f gels --trans {trans} -n 10 -m 15')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
|
|
out, err, exitcode = call_rocsolver_bench('-f gels --trans 0 -n 10 -m 15')
|
|
self.assertNotEqual(err, '')
|
|
self.assertNotEqual(exitcode, 0)
|
|
|
|
def test_validate_side(self):
|
|
for side in 'LRB':
|
|
with self.subTest(side=side):
|
|
out, err, exitcode = call_rocsolver_bench(f'-f larf --side {side} -n 10 -m 15')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
|
|
out, err, exitcode = call_rocsolver_bench('-f larf --side 0 -n 10 -m 15')
|
|
self.assertNotEqual(err, '')
|
|
self.assertNotEqual(exitcode, 0)
|
|
|
|
def test_validate_fill(self):
|
|
for fill in 'ULF':
|
|
with self.subTest(fill=fill):
|
|
out, err, exitcode = call_rocsolver_bench(f'-f bdsqr --uplo {fill} -n 15 --nu 10 --nv 10')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
|
|
out, err, exitcode = call_rocsolver_bench('-f bdsqr --uplo 0 -n 15 --nu 10 --nv 10')
|
|
self.assertNotEqual(err, '')
|
|
self.assertNotEqual(exitcode, 0)
|
|
|
|
def test_validate_diagonal(self):
|
|
for diag in 'NU':
|
|
with self.subTest(diag=diag):
|
|
out, err, exitcode = call_rocsolver_bench(f'-f trtri --diag {diag} -n 10')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
|
|
out, err, exitcode = call_rocsolver_bench('-f trtri --diag 0 -n 10')
|
|
self.assertNotEqual(err, '')
|
|
self.assertNotEqual(exitcode, 0)
|
|
|
|
def test_validate_direct(self):
|
|
for direct in 'FB':
|
|
with self.subTest(direct=direct):
|
|
out, err, exitcode = call_rocsolver_bench(f'-f larfb --direct {direct} --side L --storev C -n 10 -m 15 -k 1')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
|
|
out, err, exitcode = call_rocsolver_bench('-f larfb --direct 0 --side L --storev C -k 1 -n 10 -m 15 -k 1')
|
|
self.assertNotEqual(err, '')
|
|
self.assertNotEqual(exitcode, 0)
|
|
|
|
def test_validate_storev(self):
|
|
for storev in 'CR':
|
|
with self.subTest(storev=storev):
|
|
out, err, exitcode = call_rocsolver_bench(f'-f larft --storev {storev} -n 10 -k 1')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
|
|
out, err, exitcode = call_rocsolver_bench('-f larft --storev 0 -n 10 -k 1')
|
|
self.assertNotEqual(err, '')
|
|
self.assertNotEqual(exitcode, 0)
|
|
|
|
def test_validate_left_svect(self):
|
|
for svect in 'ASON':
|
|
with self.subTest(svect=svect):
|
|
out, err, exitcode = call_rocsolver_bench(f'-f gesvd --left_svect {svect} -n 10 -m 15')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
|
|
out, err, exitcode = call_rocsolver_bench('-f gesvd --left_svect 0 -n 10 -m 15')
|
|
self.assertNotEqual(err, '')
|
|
self.assertNotEqual(exitcode, 0)
|
|
|
|
def test_validate_right_svect(self):
|
|
for svect in 'ASON':
|
|
with self.subTest(svect=svect):
|
|
out, err, exitcode = call_rocsolver_bench(f'-f gesvd --right_svect {svect} -n 10 -m 15')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
|
|
out, err, exitcode = call_rocsolver_bench('-f gesvd --right_svect 0 -n 10 -m 15')
|
|
self.assertNotEqual(err, '')
|
|
self.assertNotEqual(exitcode, 0)
|
|
|
|
def test_validate_workmode(self):
|
|
for workmode in 'IO':
|
|
with self.subTest(workmode=workmode):
|
|
out, err, exitcode = call_rocsolver_bench(f'-f gesvd --fast_alg {workmode} -n 10 -m 15')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
|
|
out, err, exitcode = call_rocsolver_bench('-f gesvd --fast_alg 0 -n 10 -m 15')
|
|
self.assertNotEqual(err, '')
|
|
self.assertNotEqual(exitcode, 0)
|
|
|
|
def test_validate_evect(self):
|
|
for evect in 'VIN':
|
|
with self.subTest(evect=evect):
|
|
out, err, exitcode = call_rocsolver_bench(f'-f syev --evect {evect} -n 10')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
|
|
out, err, exitcode = call_rocsolver_bench('-f syev --evect 0 -n 10')
|
|
self.assertNotEqual(err, '')
|
|
self.assertNotEqual(exitcode, 0)
|
|
|
|
def test_validate_erange(self):
|
|
for erange in 'AVI':
|
|
with self.subTest(erange=erange):
|
|
out, err, exitcode = call_rocsolver_bench(f'-f stebz --erange {erange} -n 10')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
|
|
out, err, exitcode = call_rocsolver_bench('-f stebz --erange 0 -n 10')
|
|
self.assertNotEqual(err, '')
|
|
self.assertNotEqual(exitcode, 0)
|
|
|
|
def test_validate_eorder(self):
|
|
for eorder in 'BE':
|
|
with self.subTest(eorder=eorder):
|
|
out, err, exitcode = call_rocsolver_bench(f'-f stebz --eorder {eorder} -n 10')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
|
|
out, err, exitcode = call_rocsolver_bench('-f stebz --eorder 0 -n 10')
|
|
self.assertNotEqual(err, '')
|
|
self.assertNotEqual(exitcode, 0)
|
|
|
|
def test_validate_itype(self):
|
|
for itype in '123':
|
|
with self.subTest(itype=itype):
|
|
out, err, exitcode = call_rocsolver_bench(f'-f sygv --itype {itype} -n 10')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
|
|
out, err, exitcode = call_rocsolver_bench('-f sygv --itype 0 -n 10')
|
|
self.assertNotEqual(err, '')
|
|
self.assertNotEqual(exitcode, 0)
|
|
|
|
def test_unused_arg(self):
|
|
out, err, exitcode = call_rocsolver_bench('-f gels --itype 1 -n 10 -m 15')
|
|
self.assertNotEqual(err, '')
|
|
self.assertNotEqual(exitcode, 0)
|
|
|
|
def test_perf_returns_number(self):
|
|
out, err, exitcode = call_rocsolver_bench('-f gels -n 10 -m 15 --perf 1')
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
self.assertGreaterEqual(float(out), 0)
|
|
|
|
def generate_parameterized_test(command_options, expected_args):
|
|
def test_function_output(self):
|
|
out, err, exitcode = call_rocsolver_bench(command_options)
|
|
self.assertEqual(err, '')
|
|
self.assertEqual(exitcode, 0)
|
|
|
|
args = self.parse_arguments(out)
|
|
self.assertEqual(args, expected_args)
|
|
|
|
results = self.parse_results(out)
|
|
self.assertGreaterEqual(float(results['cpu_time_us']), 0)
|
|
self.assertGreaterEqual(float(results['gpu_time_us']), 0)
|
|
return test_function_output
|
|
|
|
parameters = [
|
|
(
|
|
'laswp',
|
|
'-f laswp -n 10 --k1 15 --k2 20',
|
|
{
|
|
'n': '10',
|
|
'lda': '20',
|
|
'k1': '15',
|
|
'k2': '20',
|
|
'inc': '1',
|
|
}
|
|
),
|
|
(
|
|
'larfg',
|
|
'-f larfg -n 10',
|
|
{
|
|
'n': '10',
|
|
'inc': '1',
|
|
}
|
|
),
|
|
(
|
|
'larf',
|
|
'-f larf -m 10 --side L',
|
|
{
|
|
'side': 'L',
|
|
'm': '10',
|
|
'n': '10',
|
|
'inc': '1',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'larft',
|
|
'-f larft -n 10 --storev C -k 5',
|
|
{
|
|
'direct': 'F',
|
|
'storev': 'C',
|
|
'n': '10',
|
|
'k': '5',
|
|
'ldv': '10',
|
|
'ldt': '5',
|
|
}
|
|
),
|
|
(
|
|
'larfb',
|
|
'-f larfb -n 10 -m 15 --direct F --side L --storev C -k 5',
|
|
{
|
|
'side': 'L',
|
|
'trans': 'N',
|
|
'direct': 'F',
|
|
'storev': 'C',
|
|
'm': '15',
|
|
'n': '10',
|
|
'k': '5',
|
|
'ldv': '15',
|
|
'ldt': '5',
|
|
'lda': '15',
|
|
}
|
|
),
|
|
(
|
|
'latrd',
|
|
'-f latrd -n 10 -k 5',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'k': '5',
|
|
'lda': '10',
|
|
'ldw': '10',
|
|
}
|
|
),
|
|
(
|
|
'labrd',
|
|
'-f labrd -n 10 -m 15',
|
|
{
|
|
'm': '15',
|
|
'n': '10',
|
|
'nb': '10',
|
|
'lda': '15',
|
|
'ldx': '15',
|
|
'ldy': '10',
|
|
}
|
|
),
|
|
(
|
|
'bdsqr',
|
|
'-f bdsqr --uplo U -n 15 --nu 10 --nv 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '15',
|
|
'nv': '10',
|
|
'nu': '10',
|
|
'nc': '0',
|
|
'ldv': '15',
|
|
'ldu': '10',
|
|
'ldc': '1',
|
|
}
|
|
),
|
|
(
|
|
'steqr',
|
|
'-f steqr -n 15',
|
|
{
|
|
'evect': 'N',
|
|
'n': '15',
|
|
'ldc': '15',
|
|
}
|
|
),
|
|
(
|
|
'stedc',
|
|
'-f stedc -n 15',
|
|
{
|
|
'evect': 'N',
|
|
'n': '15',
|
|
'ldc': '15',
|
|
}
|
|
),
|
|
(
|
|
'stein',
|
|
'-f stein -n 15',
|
|
{
|
|
'n': '15',
|
|
'nev': '5',
|
|
'ldz': '15',
|
|
}
|
|
),
|
|
(
|
|
'lasyf',
|
|
'-f lasyf -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'nb': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'potf2',
|
|
'-f potf2 -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'potf2_batched',
|
|
'-f potf2_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'potf2_strided_batched',
|
|
'-f potf2_strided_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'potrf',
|
|
'-f potrf -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'potrf_batched',
|
|
'-f potrf_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'potrf_strided_batched',
|
|
'-f potrf_strided_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'potrs',
|
|
'-f potrs -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'nrhs': '10',
|
|
'lda': '10',
|
|
'ldb': '10',
|
|
}
|
|
),
|
|
(
|
|
'potrs_batched',
|
|
'-f potrs_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'nrhs': '10',
|
|
'lda': '10',
|
|
'ldb': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'potrs_strided_batched',
|
|
'-f potrs_strided_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'nrhs': '10',
|
|
'lda': '10',
|
|
'ldb': '10',
|
|
'strideA': '100',
|
|
'strideB': '100',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'posv',
|
|
'-f posv -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'nrhs': '10',
|
|
'lda': '10',
|
|
'ldb': '10',
|
|
}
|
|
),
|
|
(
|
|
'posv_batched',
|
|
'-f posv_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'nrhs': '10',
|
|
'lda': '10',
|
|
'ldb': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'posv_strided_batched',
|
|
'-f posv_strided_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'nrhs': '10',
|
|
'lda': '10',
|
|
'ldb': '10',
|
|
'strideA': '100',
|
|
'strideB': '100',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'potri',
|
|
'-f potri -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'potri_batched',
|
|
'-f potri_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'potri_strided_batched',
|
|
'-f potri_strided_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getf2_npvt',
|
|
'-f getf2_npvt -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'getf2_npvt_batched',
|
|
'-f getf2_npvt_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getf2_npvt_strided_batched',
|
|
'-f getf2_npvt_strided_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getrf_npvt',
|
|
'-f getrf_npvt -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'getrf_npvt_batched',
|
|
'-f getrf_npvt_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getrf_npvt_strided_batched',
|
|
'-f getrf_npvt_strided_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getrf',
|
|
'-f getrf -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'getrf_batched',
|
|
'-f getrf_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getrf_strided_batched',
|
|
'-f getrf_strided_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getf2',
|
|
'-f getf2 -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'getf2_batched',
|
|
'-f getf2_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getf2_strided_batched',
|
|
'-f getf2_strided_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'geqr2',
|
|
'-f geqr2 -n 10 -m 15',
|
|
{
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
}
|
|
),
|
|
(
|
|
'geqr2_batched',
|
|
'-f geqr2_batched -n 10 -m 15',
|
|
{
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'geqr2_strided_batched',
|
|
'-f geqr2_strided_batched -n 10 -m 15',
|
|
{
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
'strideA': '150',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'geqrf',
|
|
'-f geqrf -n 10 -m 15',
|
|
{
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
}
|
|
),
|
|
(
|
|
'geqrf_batched',
|
|
'-f geqrf_batched -n 10 -m 15',
|
|
{
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'geqrf_strided_batched',
|
|
'-f geqrf_strided_batched -n 10 -m 15',
|
|
{
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
'strideA': '150',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'geqrf_ptr_batched',
|
|
'-f geqrf_ptr_batched -n 10 -m 15',
|
|
{
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gerq2',
|
|
'-f gerq2 -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'gerq2_batched',
|
|
'-f gerq2_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gerq2_strided_batched',
|
|
'-f gerq2_strided_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gerqf',
|
|
'-f gerqf -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'gerqf_batched',
|
|
'-f gerqf_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gerqf_strided_batched',
|
|
'-f gerqf_strided_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'geql2',
|
|
'-f geql2 -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'geql2_batched',
|
|
'-f geql2_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'geql2_strided_batched',
|
|
'-f geql2_strided_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'geqlf',
|
|
'-f geqlf -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'geqlf_batched',
|
|
'-f geqlf_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'geqlf_strided_batched',
|
|
'-f geqlf_strided_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gelq2',
|
|
'-f gelq2 -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'gelq2_batched',
|
|
'-f gelq2_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gelq2_strided_batched',
|
|
'-f gelq2_strided_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gelqf',
|
|
'-f gelqf -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'gelqf_batched',
|
|
'-f gelqf_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gelqf_strided_batched',
|
|
'-f gelqf_strided_batched -m 10',
|
|
{
|
|
'm': '10',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getrs',
|
|
'-f getrs -n 10',
|
|
{
|
|
'trans': 'N',
|
|
'n': '10',
|
|
'nrhs': '10',
|
|
'lda': '10',
|
|
'ldb': '10',
|
|
}
|
|
),
|
|
(
|
|
'getrs_batched',
|
|
'-f getrs_batched -n 10',
|
|
{
|
|
'trans': 'N',
|
|
'n': '10',
|
|
'nrhs': '10',
|
|
'lda': '10',
|
|
'ldb': '10',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getrs_strided_batched',
|
|
'-f getrs_strided_batched -n 10',
|
|
{
|
|
'trans': 'N',
|
|
'n': '10',
|
|
'nrhs': '10',
|
|
'lda': '10',
|
|
'ldb': '10',
|
|
'strideA': '100',
|
|
'strideP': '10',
|
|
'strideB': '100',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gesv',
|
|
'-f gesv -n 10',
|
|
{
|
|
'n': '10',
|
|
'nrhs': '10',
|
|
'lda': '10',
|
|
'ldb': '10',
|
|
}
|
|
),
|
|
(
|
|
'gesv_batched',
|
|
'-f gesv_batched -n 10',
|
|
{
|
|
'n': '10',
|
|
'nrhs': '10',
|
|
'lda': '10',
|
|
'ldb': '10',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gesv_strided_batched',
|
|
'-f gesv_strided_batched -n 10',
|
|
{
|
|
'n': '10',
|
|
'nrhs': '10',
|
|
'lda': '10',
|
|
'ldb': '10',
|
|
'strideA': '100',
|
|
'strideP': '10',
|
|
'strideB': '100',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gesvd',
|
|
'-f gesvd -n 10 -m 15',
|
|
{
|
|
'left_svect': 'N',
|
|
'right_svect': 'N',
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
'ldu': '15',
|
|
'ldv': '10',
|
|
}
|
|
),
|
|
(
|
|
'gesvd_batched',
|
|
'-f gesvd_batched -n 10 -m 15',
|
|
{
|
|
'left_svect': 'N',
|
|
'right_svect': 'N',
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
'strideS': '10',
|
|
'ldu': '15',
|
|
'strideU': '225',
|
|
'ldv': '10',
|
|
'strideV': '100',
|
|
'strideE': '9',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gesvd_strided_batched',
|
|
'-f gesvd_strided_batched -n 10 -m 15',
|
|
{
|
|
'left_svect': 'N',
|
|
'right_svect': 'N',
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
'strideA': '150',
|
|
'strideS': '10',
|
|
'ldu': '15',
|
|
'strideU': '225',
|
|
'ldv': '10',
|
|
'strideV': '100',
|
|
'strideE': '9',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'trtri',
|
|
'-f trtri -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'diag': 'N',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'trtri_batched',
|
|
'-f trtri_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'diag': 'N',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'trtri_strided_batched',
|
|
'-f trtri_strided_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'diag': 'N',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getri',
|
|
'-f getri -n 10',
|
|
{
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'getri_batched',
|
|
'-f getri_batched -n 10',
|
|
{
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getri_strided_batched',
|
|
'-f getri_strided_batched -n 10',
|
|
{
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getri_npvt',
|
|
'-f getri_npvt -n 10',
|
|
{
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'getri_npvt_batched',
|
|
'-f getri_npvt_batched -n 10',
|
|
{
|
|
'n': '10',
|
|
'lda': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getri_npvt_strided_batched',
|
|
'-f getri_npvt_strided_batched -n 10',
|
|
{
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getri_outofplace',
|
|
'-f getri_outofplace -n 10',
|
|
{
|
|
'n': '10',
|
|
'lda': '10',
|
|
'ldc': '10',
|
|
}
|
|
),
|
|
(
|
|
'getri_outofplace_batched',
|
|
'-f getri_outofplace_batched -n 10',
|
|
{
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideP': '10',
|
|
'ldc': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getri_outofplace_strided_batched',
|
|
'-f getri_outofplace_strided_batched -n 10',
|
|
{
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'strideP': '10',
|
|
'ldc': '10',
|
|
'strideC': '100',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getri_npvt_outofplace',
|
|
'-f getri_npvt_outofplace -n 10',
|
|
{
|
|
'n': '10',
|
|
'lda': '10',
|
|
'ldc': '10',
|
|
}
|
|
),
|
|
(
|
|
'getri_npvt_outofplace_batched',
|
|
'-f getri_npvt_outofplace_batched -n 10',
|
|
{
|
|
'n': '10',
|
|
'lda': '10',
|
|
'ldc': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'getri_npvt_outofplace_strided_batched',
|
|
'-f getri_npvt_outofplace_strided_batched -n 10',
|
|
{
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'ldc': '10',
|
|
'strideC': '100',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gels',
|
|
'-f gels -n 10 -m 15',
|
|
{
|
|
'trans': 'N',
|
|
'm': '15',
|
|
'n': '10',
|
|
'nrhs': '10',
|
|
'lda': '15',
|
|
'ldb': '15',
|
|
}
|
|
),
|
|
(
|
|
'gels_batched',
|
|
'-f gels_batched -n 10 -m 15',
|
|
{
|
|
'trans': 'N',
|
|
'm': '15',
|
|
'n': '10',
|
|
'nrhs': '10',
|
|
'lda': '15',
|
|
'ldb': '15',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gels_strided_batched',
|
|
'-f gels_strided_batched -n 10 -m 15',
|
|
{
|
|
'trans': 'N',
|
|
'm': '15',
|
|
'n': '10',
|
|
'nrhs': '10',
|
|
'lda': '15',
|
|
'ldb': '15',
|
|
'strideA': '150',
|
|
'strideB': '150',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gebd2',
|
|
'-f gebd2 -n 10 -m 15',
|
|
{
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
}
|
|
),
|
|
(
|
|
'gebd2_batched',
|
|
'-f gebd2_batched -n 10 -m 15',
|
|
{
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gebd2_strided_batched',
|
|
'-f gebd2_strided_batched -n 10 -m 15',
|
|
{
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
'strideA': '150',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gebrd',
|
|
'-f gebrd -n 10 -m 15',
|
|
{
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
}
|
|
),
|
|
(
|
|
'gebrd_batched',
|
|
'-f gebrd_batched -n 10 -m 15',
|
|
{
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'gebrd_strided_batched',
|
|
'-f gebrd_strided_batched -n 10 -m 15',
|
|
{
|
|
'm': '15',
|
|
'n': '10',
|
|
'lda': '15',
|
|
'strideA': '150',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'sytf2',
|
|
'-f sytf2 -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'sytf2_batched',
|
|
'-f sytf2_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'sytf2_strided_batched',
|
|
'-f sytf2_strided_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'sytrf',
|
|
'-f sytrf -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'lda': '10',
|
|
}
|
|
),
|
|
(
|
|
'sytrf_batched',
|
|
'-f sytrf_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
),
|
|
(
|
|
'sytrf_strided_batched',
|
|
'-f sytrf_strided_batched -n 10',
|
|
{
|
|
'uplo': 'U',
|
|
'n': '10',
|
|
'lda': '10',
|
|
'strideA': '100',
|
|
'strideP': '10',
|
|
'batch_c': '1',
|
|
}
|
|
)
|
|
]
|
|
|
|
if __name__ == '__main__':
|
|
for name, command_options, expected_args in parameters:
|
|
test = generate_parameterized_test(command_options, expected_args)
|
|
setattr(TestRocsolverBench, f'test_{name}', test)
|
|
unittest.main()
|